raap 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 507ed156280ed3e0db1f2eb454bb03c57aa473d537d8c6ea5905ad852eba550d
-  data.tar.gz: 3108fa50c664702f79141a3c0b5e83934d6742468d1d51bfb2febb5b64a00b12
+  metadata.gz: 94f0ec4ff924c5089f8e307002dd5f3cd778f04e686acd8b46466139c3c1aebd
+  data.tar.gz: e9a06fb3c71cfc6cd605031fe8cb899a123dc82a94ef00586d39e8329c45beac
 SHA512:
-  metadata.gz: 269e220d72b9861881de860a71a2adff318105595880fe73e86492e255c9bb32fbeff7ac3685b83ea11d792a02b1509eb969d9956483a9415608530a3f8806bd
-  data.tar.gz: df4e40973681eb292d7844aa5ed1427b7155f619c6ebea53792149f430ab28e42a0a0f52df9517a3af9af1e08494eaccdd8d4d84313c9d24184f6403a51e1dc5
+  metadata.gz: ed0d647fefa8591c0a03981232c84d64bf7c70bcf9207d2dd6471a9f3369747b5dd3adcc3cd60a8e1d65f0e1543ed7a5f5108eef6523c7d306cfc399d0bc63e4
+  data.tar.gz: 537c5dfbb65bb12064e46c47fb75a60321ee0f16296f1272ef27d68927f4f9f3d5875ea6f3ac2225c76a2d274fbe393bff20f573b8d138b52a6ced8027528e1f

data/.rubocop.yml

@@ -0,0 +1,31 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+  Include:
+  - 'lib/**/*.rb'
+
+Lint:
+  Enabled: true
+Lint/EmptyBlock:
+  Enabled: false
+
+Style:
+  Enabled: false
+Style/HashSyntax:
+  EnforcedShorthandSyntax: always
+  Enabled: true
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Metrics:
+  Enabled: false
+
+Layout:
+  Enabled: true
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+Layout/LineLength:
+  Max: 150
+
+Naming:
+  Enabled: false

data/README.md

@@ -1,5 +1,7 @@
 # RaaP
 
+<img src="https://raw.githubusercontent.com/ksss/raap/main/public/jacket.webp" width=400/>
+
 ## RBS as a Property
 
 RaaP is a property based testing tool.
@@ -55,7 +57,7 @@ Finally, you get the perfect RBS!
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add raap
+    $ bundle add raap --require false
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
@@ -68,6 +70,15 @@ $ raap 'MyClass'                  # Run only RBS of MyClass
 $ raap 'MyClass::*'               # Run each class under MyClass
 $ raap 'MyClass.singleton_method' # Run only MyClass.singleton_method
 $ raap 'MyClass#instance_method'  # Run only MyClass#instance_method
+$ raap 'MyClass' '!MyClass#skip'  # Run method MyClass without #skip
+```
+
+```
+$ cat test/raap.txt
+MyClass
+!MyClass#skip
+
+$ raap $(cat test/raap.txt)   # You can manage the methods to be tested in a file
 ```
 
 ## Size
@@ -101,11 +112,15 @@ You can specify to load specify PATH as RBS.
 
 ### `--library lib`
 
-You can specify to load RBS library
+You can specify to load RBS library.
 
 ### `--require lib`
 
-You can specify require Ruby library
+You can specify require Ruby library.
+
+### `--log-level level`
+
+You can specify log level (debug, info, warn or error).
 
 ### `--timeout sec`
 
@@ -123,6 +138,15 @@ You can specify size of end.
 
 You can specify size of step like `Integer#step: (to: Integer, by: Integer)`.
 
+### `--allow-private`
+
+By default, raap only validates public methods.
+However, by setting this option, it is possible to intentionally validate private methods in the RBS.
+
+## First support is CLI
+
+In RaaP, usage through the CLI is the primary support focus, and efforts are made to maintain compatibility. The use of the library's code (such as `RaaP::Type`) does not guarantee compatibility.
+
 ## Achievements
 
 RaaP has already found many RBS mistakes and bug in CRuby during the development phase.
@@ -134,6 +158,11 @@ RaaP has already found many RBS mistakes and bug in CRuby during the development
 * https://github.com/ruby/rbs/pull/1769
 * https://github.com/ruby/rbs/pull/1770
 * https://github.com/ruby/rbs/pull/1771
+* https://github.com/ruby/rbs/pull/1779
+* https://github.com/ruby/rbs/pull/1783
+* https://github.com/ruby/rbs/pull/1789
+* https://github.com/ruby/rbs/pull/1790
+* https://github.com/ruby/rbs/pull/1793
 
 ## Development
 

data/Rakefile

@@ -2,7 +2,16 @@
 
 require "bundler/gem_tasks"
 require "minitest/test_task"
+require "rubocop/rake_task"
 
 Minitest::TestTask.create
 
-task default: :test
+RuboCop::RakeTask.new
+
+namespace :steep do
+  task :check do
+    sh "bundle exec steep check"
+  end
+end
+
+task default: [:test, :rubocop, 'steep:check']

data/exe/raap

@@ -1,3 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
 require 'raap'
 
-RaaP::CLI.new(ARGV).load.run
+exit RaaP::CLI.new(ARGV).load.run

data/lib/raap/bind_call.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module RaaP
   module BindCall
     class << self
-      def define_singleton_method(...) = ::Object.instance_method(:define_singleton_method).bind_call(...)
+      def define_method(...) = ::Module.instance_method(:define_method).bind_call(...)
       def respond_to?(...) = ::Kernel.instance_method(:respond_to?).bind_call(...)
       def instance_of?(...) = ::Kernel.instance_method(:instance_of?).bind_call(...)
       def is_a?(...) = ::Kernel.instance_method(:is_a?).bind_call(...)
@@ -11,19 +13,31 @@ module RaaP
       def public_send(...) = ::Kernel.instance_method(:public_send).bind_call(...)
 
       def class(obj)
-        if respond_to?(obj, :class)
-          obj.class
-        else
+        if instance_of?(obj, BasicObject)
           ::Kernel.instance_method(:class).bind_call(obj)
+        else
+          obj.class
         end
       end
 
       def inspect(obj)
-        if respond_to?(obj, :inspect)
-          obj.inspect
-        else
+        if instance_of?(obj, BasicObject)
           ::Kernel.instance_method(:inspect).bind_call(obj)
+        else
+          case obj
+          when Hash
+            body = obj.map do |k, v|
+              "#{inspect(k)} => #{inspect(v)}"
+            end
+            "{#{body.join(', ')}}"
+          when Array
+            "[#{obj.map { |o| inspect(o) }.join(', ')}]"
+          else
+            obj.inspect
+          end
         end
+      rescue NoMethodError
+        "#<#{self.class(obj)}>"
       end
     end
   end

data/lib/raap/cli.rb

@@ -2,12 +2,7 @@
 
 module RaaP
   # $ raap Integer#pow
-  # $ raap -I sig RaaP::Type
   class CLI
-    class << self
-      attr_accessor :option
-    end
-
     Option = Struct.new(
       :dirs,
       :requires,
@@ -20,60 +15,80 @@ module RaaP
       keyword_init: true
     )
 
-    # defaults
-    self.option = Option.new(
-      dirs: [],
-      requires: [],
-      libraries: [],
-      timeout: 3,
-      size_from: 0,
-      size_to: 99,
-      size_by: 1,
-      allow_private: false,
-    )
+    # Should skip methods has side effects
+    DEFAULT_SKIP = Set.new
+    %i[
+      fork system exec spawn `
+      abort exit exit! raise fail
+      load require require_relative
+      gem
+    ].each do |kernel_method|
+      DEFAULT_SKIP << "::Kernel##{kernel_method}"
+      DEFAULT_SKIP << "::Kernel.#{kernel_method}"
+    end
+    %i[
+      delete unlink chmod lchmod chown lchown
+      link mkfifo new open rename truncate
+    ].each { |m| DEFAULT_SKIP << "::File.#{m}" }
+    %i[flock truncate].each { |m| DEFAULT_SKIP << "::File##{m}" }
+
+    attr_accessor :option, :argv, :skip, :results
 
     def initialize(argv)
+      # defaults
+      @option = Option.new(
+        dirs: [],
+        requires: [],
+        libraries: [],
+        timeout: 3,
+        size_from: 0,
+        size_to: 99,
+        size_by: 1,
+        allow_private: false,
+      )
       @argv = argv
+      @skip = DEFAULT_SKIP.dup
+      @results = []
     end
 
     def load
       OptionParser.new do |o|
         o.on('-I', '--include PATH') do |path|
-          CLI.option.dirs << path
+          @option.dirs << path
         end
         o.on('--library lib', 'load rbs library') do |lib|
-          CLI.option.libraries << lib
+          @option.libraries << lib
         end
         o.on('--require lib', 'require ruby library') do |lib|
-          CLI.option.requires << lib
+          @option.requires << lib
         end
-        o.on('--log-level level', "default: warn") do |arg|
+        o.on('--log-level level', "default: info") do |arg|
           RaaP.logger.level = arg
         end
-        o.on('--timeout sec', Integer, "default: #{CLI.option.timeout}") do |arg|
-          CLI.option.timeout = arg
+        o.on('--timeout sec', Float, "default: #{@option.timeout}") do |arg|
+          @option.timeout = arg
         end
-        o.on('--size-from int', Integer, "default: #{CLI.option.size_from}") do |arg|
-          CLI.option.size_from = arg
+        o.on('--size-from int', Integer, "default: #{@option.size_from}") do |arg|
+          @option.size_from = arg
         end
-        o.on('--size-to int', Integer, "default: #{CLI.option.size_to}") do |arg|
-          CLI.option.size_to = arg
+        o.on('--size-to int', Integer, "default: #{@option.size_to}") do |arg|
+          @option.size_to = arg
         end
-        o.on('--size-by int', Integer, "default: #{CLI.option.size_by}") do |arg|
-          CLI.option.size_by = arg
+        o.on('--size-by int', Integer, "default: #{@option.size_by}") do |arg|
+          @option.size_by = arg
         end
-        o.on('--allow-private', "default: #{CLI.option.allow_private}") do
-          CLI.option.allow_private = true
+        o.on('--allow-private', "default: #{@option.allow_private}") do
+          @option.allow_private = true
         end
       end.parse!(@argv)
 
-      CLI.option.dirs.each do |dir|
+      @option.dirs.each do |dir|
         RaaP::RBS.loader.add(path: Pathname(dir))
       end
-      CLI.option.libraries.each do |lib|
+      @option.libraries.each do |lib|
         RaaP::RBS.loader.add(library: lib, version: nil)
       end
-      CLI.option.requires.each do |lib|
+      @option.requires.each do |lib|
         require lib
       end
 
@@ -81,137 +96,195 @@ module RaaP
     end
 
     def run
-      @argv.map do |tag|
+      Signal.trap(:INT) do
+        puts "Interrupted by SIGINT"
+        report
+        exit 1
+      end
+
+      # Search skip tag
+      @argv.each do |tag|
+        if tag.start_with?('!') && (tag.include?('#') || tag.include?('.'))
+          t = tag[1..] or raise
+          t = "::#{t}" unless t.start_with?('::')
+          t or raise
+          @skip << t
+        end
+      end
+      @skip.freeze
+
+      @argv.each do |tag|
+        next if tag.start_with?('!')
+
         case
         when tag.include?('#')
-          run_by_instance(tag:)
+          run_by(kind: :instance, tag:)
         when tag.include?('.')
-          run_by_singleton(tag:)
+          run_by(kind: :singleton, tag:)
         when tag.end_with?('*')
           run_by_type_name_with_search(tag:)
         else
           run_by_type_name(tag:)
         end
-      end.each do |ret|
-        ret.each do |methods|
-          methods.each do |status, method_name, method_type|
-            if status == 1
-              puts "Fail:"
-              puts "def #{method_name}: #{method_type}"
-            end
-          end
-        end
       end
 
-      self
+      report
     end
 
-    def run_by_instance(tag:)
-      t, m = tag.split('#', 2)
-      t or raise
-      m or raise
-      type = RBS.parse_type(t)
-      type = __skip__ = type
-      raise "cannot specified #{type}" unless type.respond_to?(:name)
-      receiver_type = Type.new(type.to_s)
-      method_name = m.to_sym
-      definition = RBS.builder.build_instance(type.name)
-      type_params_decl = definition.type_params_decl
-      method = definition.methods[method_name]
-      raise "`#{tag}` is not found" unless method
-      puts "# #{type.to_s}"
-      puts
-      [
-        method.method_types.map do |method_type|
-          property(receiver_type:, type_params_decl:, method_type:, method_name:)
+    private
+
+    def report
+      i = 0
+      exit_status = 0
+      @results.each do |ret|
+        ret => { method:, properties: }
+        properties.select { |status,| status == 1 }.each do |_, method_name, method_type, reason|
+          i += 1
+          location = if method.alias_of
+                       alias_decl = RBS.find_alias_decl(method.defined_in, method_name) or raise "alias decl not found: #{method_name}"
+                       alias_decl.location
+                     else
+                       method_type.location
+                     end
+          prefix = method.defs.first.member.kind == :instance ? '' : 'self.'
+
+          puts "\e[41m\e[1m#\e[m\e[1m #{i}) Failure:\e[m"
+          puts
+          puts "def #{prefix}#{method_name}: #{method_type}"
+          puts "  in #{location}"
+          puts
+          puts "## Reason"
+          puts
+          puts reason&.string
+          puts
+          exit_status = 1
         end
-      ]
+      end
+      exit_status
     end
 
-    def run_by_singleton(tag:)
-      t, m = tag.split('.', 2)
+    def run_by(kind:, tag:)
+      split = kind == :instance ? '#' : '.'
+      t, m = tag.split(split, 2)
       t or raise
       m or raise
       type = RBS.parse_type(t)
       raise "cannot specified #{type.class}" unless type.respond_to?(:name)
+
       type = __skip__ = type
-      receiver_type = Type.new("singleton(#{type.name})")
+      type_name = type.name.absolute!
+      type_to_s = type.to_s.start_with?('::') ? type.to_s : "::#{type}"
+      receiver_type = if kind == :instance
+                        Type.new(type_to_s)
+                      else
+                        Type.new("singleton(#{type_name})")
+                      end
       method_name = m.to_sym
-      definition = RBS.builder.build_singleton(type.name)
+      definition = if kind == :instance
+                     RBS.builder.build_instance(type_name)
+                   else
+                     RBS.builder.build_singleton(type_name)
+                   end
+
       method = definition.methods[method_name]
-      type_params_decl = definition.type_params_decl
       raise "`#{tag}` not found" unless method
-      puts "# #{type}"
-      puts
-      [
-        method.method_types.map do |method_type|
-          property(receiver_type:, type_params_decl:, method_type:, method_name:)
+
+      if @skip.include?("#{type_name}#{split}#{method_name}")
+        raise "`#{type_name}#{split}#{method_name}` is a method to be skipped"
+      end
+
+      type_params_decl = definition.type_params_decl
+      type_args = type.args
+
+      RaaP.logger.info("# #{type}")
+      @results << {
+        method:,
+        properties: method.method_types.map do |method_type|
+          property(receiver_type:, type_params_decl:, type_args:, method_type:, method_name:)
         end
-      ]
+      }
     end
 
     def run_by_type_name_with_search(tag:)
       first, _last = tag.split('::')
-      ret = []
-      RBS.env.class_decls.each do |name, entry|
-        if ['', '::'].any? { |pre| name.to_s.match?(/\A#{pre}#{first}\b/) }
-          ret << run_by_type_name(tag: name.to_s)
+      RBS.env.class_decls.each do |name, _entry|
+        if ['', '::'].any? { |pre| name.to_s.start_with?("#{pre}#{first}") }
+          if @skip.include?(name.to_s)
+            RaaP.logger.info("Skip #{name}")
+            next
+          end
+          run_by_type_name(tag: name.to_s)
         end
       end
-      ret.flatten(1)
     end
 
     def run_by_type_name(tag:)
       type = RBS.parse_type(tag)
       type = __skip__ = type
       raise "cannot specified #{type.class}" unless type.respond_to?(:name)
-      type_name = type.name.absolute!
 
-      ret = []
+      type_name = type.name.absolute!
+      type_args = type.args
 
       definition = RBS.builder.build_singleton(type_name)
       type_params_decl = definition.type_params_decl
-      definition.methods.filter_map do |method_name, method|
+      definition.methods.each do |method_name, method|
+        if @skip.include?("#{type_name.absolute!}.#{method_name}")
+          RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")
+          next
+        end
         next unless method.accessibility == :public
         next if method.defined_in != type_name
-        next if method_name == :fork || method_name == :spawn # TODO: skip solution
-        puts "# #{type_name}.#{method_name}"
-        puts
-        ret << method.method_types.map do |method_type|
-          property(receiver_type: Type.new("singleton(#{type})"), type_params_decl:, method_type:, method_name:)
-        end
+
+        RaaP.logger.info("# #{type_name}.#{method_name}")
+        @results << {
+          method:,
+          properties: method.method_types.map do |method_type|
+            property(receiver_type: Type.new("singleton(#{type.name})"), type_params_decl:, type_args:, method_type:, method_name:)
+          end
+        }
       end
 
       definition = RBS.builder.build_instance(type_name)
       type_params_decl = definition.type_params_decl
-      definition.methods.filter_map do |method_name, method|
+      definition.methods.each do |method_name, method|
+        if @skip.include?("#{type_name.absolute!}##{method_name}")
+          RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")
+          next
+        end
         next unless method.accessibility == :public
         next if method.defined_in != type_name
-        next if method_name == :fork || method_name == :spawn # TODO: skip solution
-        puts "# #{type_name}##{method_name}"
-        puts
-        ret << method.method_types.map do |method_type|
-          property(receiver_type: Type.new(type.to_s), type_params_decl:, method_type:, method_name:)
-        end
-      end
 
-      ret
+        RaaP.logger.info("# #{type_name}##{method_name}")
+        @results << {
+          method:,
+          properties: method.method_types.map do |method_type|
+            property(receiver_type: Type.new(type.name), type_params_decl:, type_args:, method_type:, method_name:)
+          end
+        }
+      end
     end
 
-    def property(receiver_type:, type_params_decl:, method_type:, method_name:)
+    def property(receiver_type:, type_params_decl:, type_args:, method_type:, method_name:)
       rtype = __skip__ = receiver_type.type
       if receiver_type.type.instance_of?(::RBS::Types::ClassSingleton)
         prefix = 'self.'
-        type_args = []
       else
         prefix = ''
-        type_args = rtype.args
       end
-      puts "## def #{prefix}#{method_name}: #{method_type}"
+
+      # type_args delegate to self_type
+      type_params_decl.each_with_index do |param, i|
+        if rtype.instance_of?(::RBS::Types::ClassInstance)
+          rtype.args[i] = type_args[i] || param.upper_bound || ::RBS::Types::Bases::Any.new(location: nil)
+        end
+      end
+      RaaP.logger.info("## def #{prefix}#{method_name}: #{method_type}")
       status = 0
-      stats = MethodProperty.new(
+      reason = nil
+      prop = MethodProperty.new(
         receiver_type:,
-        method_name: method_name,
+        method_name:,
         method_type: MethodType.new(
           method_type,
           type_params_decl:,
@@ -220,46 +293,59 @@ module RaaP
           instance_type: ::RBS::Types::ClassInstance.new(name: rtype.name, args: type_args, location: nil),
           class_type: ::RBS::Types::ClassSingleton.new(name: rtype.name, location: nil),
         ),
-        size_step: CLI.option.size_from.step(to: CLI.option.size_to, by: CLI.option.size_by),
-        timeout: CLI.option.timeout,
-        allow_private: true,
-      ).run do |called|
+        size_step: @option.size_from.step(to: @option.size_to, by: @option.size_by),
+        timeout: @option.timeout,
+        allow_private: @option.allow_private,
+      )
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      stats = prop.run do |called|
         case called
         in Result::Success => s
           print '.'
           RaaP.logger.debug { "Success: #{s.called_str}" }
         in Result::Failure => f
           puts 'F'
-          puts "Failed in case of `#{f.called_str}`"
-          if e = f.exception
-            RaaP.logger.debug { "Failure: [#{e.class}] #{e.message}" }
+          if (e = f.exception)
+            RaaP.logger.info { "Failure: [#{e.class}] #{e.message}" }
+            RaaP.logger.debug { e.backtrace.join("\n") }
           end
-          puts
           RaaP.logger.debug { PP.pp(f.symbolic_call, ''.dup) }
-          puts "### call stack:"
-          puts
-          puts "```"
-          puts SymbolicCaller.new(f.symbolic_call).to_lines.join("\n")
-          puts "```"
+          reason = StringIO.new
+          reason.puts "Failed in case of `#{f.called_str}`"
+          reason.puts
+          reason.puts "### Repro"
+          reason.puts
+          reason.puts "```rb"
+          reason.puts SymbolicCaller.new(f.symbolic_call).to_lines.join("\n")
+          reason.puts "```"
           status = 1
           throw :break
         in Result::Skip => s
           print 'S'
-          RaaP.logger.debug { PP.pp(s.symbolic_call, ''.dup) }
-          RaaP.logger.debug("Skip: [#{s.exception.class}] #{s.exception.message}")
+          RaaP.logger.debug { "\n```\n#{SymbolicCaller.new(s.symbolic_call).to_lines.join("\n")}\n```" }
+          RaaP.logger.debug("Skip: #{s.exception.detailed_message}")
           RaaP.logger.debug(s.exception.backtrace.join("\n"))
         in Result::Exception => e
           print 'E'
-          RaaP.logger.debug { PP.pp(e.symbolic_call, ''.dup) }
-          RaaP.logger.debug("Exception: [#{e.exception.class}] #{e.exception.message}")
+          RaaP.logger.debug { "\n```\n#{SymbolicCaller.new(e.symbolic_call).to_lines.join("\n")}\n```" }
+          RaaP.logger.debug("Exception: #{e.exception.detailed_message}")
           RaaP.logger.debug(e.exception.backtrace.join("\n"))
         end
       end
+      end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       puts
-      puts "success: #{stats.success}, skip: #{stats.skip}, exception: #{stats.exception}"
-      puts
+      time_diff = end_time - start_time
+      time = ", time: #{(time_diff * 1000).round}ms"
+      stats_log = "success: #{stats.success}, skip: #{stats.skip}, exception: #{stats.exception}#{time}"
+      RaaP.logger.info(stats_log)
+
+      if status == 0 && stats.success.zero? && !stats.break
+        status = 1
+        reason = StringIO.new
+        reason.puts "Never succeeded => #{stats_log}"
+      end
 
-      [status, method_name, method_type]
+      [status, method_name, method_type, reason]
     end
   end
 end