lib/raap/method_property.rb in raap-0.5.0 vs lib/raap/method_property.rb in raap-0.6.0

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module RaaP
   class MethodProperty
-    class Stats < Struct.new(:success, :skip, :exception, :break)
+    class Stats < Struct.new(:success, :skip, :exception, :break, keyword_init: true)
       def initialize(success: 0, skip: 0, exception: 0, break: false)
         super
       end
     end
 
@@ -21,11 +21,11 @@
       stats = Stats.new
       begin
         Timeout.timeout(@timeout) do
           catch(:break) do
             @size_step.each do |size|
-              call(size:, stats:).tap do |ret|
+              call(size: size, stats: stats).tap do |ret|
                 case ret
                 when Result::Success
                   stats.success += 1
                 when Result::Failure
                   # no count
@@ -53,12 +53,12 @@
       if @method_type.rbs.type.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) }
         RaaP.logger.info { "Skip type check since `#{@method_type.rbs}` includes `untyped`" }
         stats.break = true
         throw :break
       end
-      receiver_value = @receiver_type.to_symbolic_call(size:)
-      args, kwargs, block = @method_type.arguments_to_symbolic_call(size:)
+      receiver_value = @receiver_type.to_symbolic_call(size: size)
+      args, kwargs, block = @method_type.arguments_to_symbolic_call(size: size)
       # @type var symbolic_call: symbolic_call
       symbolic_call = [:call, receiver_value, @method_name, args, kwargs, block]
       symbolic_caller = SymbolicCaller.new(symbolic_call, allow_private: @allow_private)
       begin
         # ensure symbolic_call
@@ -75,39 +75,39 @@
             RaaP.logger.error("[#{e.class}] class is not supported to check `bot` type")
             raise
           end
         else
           return_value = symbolic_caller.eval
-          check = check_return(receiver_value:, return_value:)
+          check = check_return(receiver_value: receiver_value, return_value: return_value)
         end
         case check
         in [:success]
-          Result::Success.new(symbolic_call:, return_value:)
+          Result::Success.new(symbolic_call: symbolic_call, return_value: return_value)
         in [:failure]
-          Result::Failure.new(symbolic_call:, return_value:)
+          Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value)
         in [:exception, exception]
-          Result::Exception.new(symbolic_call:, exception:)
+          Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
         end
       rescue TypeError => exception
-        Result::Failure.new(symbolic_call:, return_value:, exception:)
+        Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value, exception: exception)
       end
 
     # not ensure symbolic_call
     rescue NoMethodError, NotImplementedError => exception
-      Result::Skip.new(symbolic_call:, exception:)
+      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
     rescue NameError => e
-      RaaP.logger.error("[#{e.class}] #{e.detailed_message}")
+      RaaP.logger.warn("[#{e.class}] #{e.detailed_message}")
       msg = e.name.nil? ? '' : "for `#{BindCall.to_s(e.receiver)}::#{e.name}`"
       RaaP.logger.warn("Implementation is not found #{msg} maybe.")
       RaaP.logger.debug(e.backtrace&.join("\n"))
       stats.break = true
       throw :break
     rescue SystemStackError => exception
       RaaP.logger.info "Found recursive type definition."
-      Result::Skip.new(symbolic_call:, exception:)
+      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
     rescue => exception
-      Result::Exception.new(symbolic_call:, exception:)
+      Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
     end
 
     def check_return(receiver_value:, return_value:)
       if BindCall.is_a?(receiver_value, Module)
         if BindCall.is_a?(return_type, ::RBS::Types::ClassSingleton)
@@ -124,11 +124,11 @@
       else
         self_class = BindCall.class(receiver_value)
         instance_class = BindCall.class(receiver_value)
       end
       type_check = ::RBS::Test::TypeCheck.new(
-        self_class:,
-        instance_class:,
+        self_class: self_class,
+        instance_class: instance_class,
         class_class: Module,
         builder: RBS.builder,
         sample_size: 100,
         unchecked_classes: []
       )