raap 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 272cb44584fb297591d356de0c90ecfbcf782951ed4a02432eb4cd87a6849f0f
-  data.tar.gz: d0776eeeb3f840a1730f16a9df385414e3697631191961b986085773cad49e04
+  metadata.gz: 312e27904176673d6962904901cb3e8d31c6b613b8efdf669c877d4670cf9d15
+  data.tar.gz: fe940b9d2928a54bfbba8a4842c097cb2a8efe6cf0b873baa383f757de37d017
 SHA512:
-  metadata.gz: '09ace505a4973cac5f075a133fc6e13c8fa34bde72adf522cc095ad3accfccec574b3209aaf4bca8deceb398b5b36f0893672722504895d51413c65877efc167'
-  data.tar.gz: 1fe3eb4b5695bd69b2a30fdd2035a81aa3be1a289dee120f4664f95bb1d6d9a5ab8849f11acb957e8ac97e8dfb174f49536542fc96f29ecfade076e15b76619e
+  metadata.gz: 55070cb0335ae161e3a1f6e62d9faa9d205e0b1c92186d2e81eaea2547d476d092fa90a9c6607d2d4ad11cf1f0a0bab723539e90cc4932d49bc297e069e07632
+  data.tar.gz: 771e2f640454bfcd8774ccc0d1ac3079df7e6f1edb7d209327881fea2febb6bbfe04af937481e3e6d81bf9b05046860fc7d861af38b523872d1af8d62a0717da

data/.rubocop.yml

@@ -0,0 +1,29 @@
+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
+
+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
 
+![Jacket](https://raw.githubusercontent.com/ksss/raap/main/public/DALL%C2%B7E%202024-03-23%2000.02.29%20-%20Imagine%20a%20scene%20where%20the%20abstract%20concepts%20of%20Ruby%20programming%20and%20property-based%20testing%20blend%20harmoniously.%20Picture%20a%20large%2C%20glowing%20ruby%20crystal%2C%20.webp)
+
 ## 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:
 
@@ -78,6 +80,21 @@ For example, an Integer with size zero is `0` and an Array is `[]`.
 
 RaaP, like other property-based tests, changes the size 100 times from 0 to 99 by default to generate test data.
 
+## Symbolic call
+
+You may possibly see the following data structure in the debug logs.
+
+```rb
+[:call, Object, :method, [], {}, nil]
+```
+
+This is a data structure of the state of the method call.
+
+Symbolic call is a tuple beginning with `:call`, followed by the receiver, method name, positional arguments, keyword arguments, and block arguments, in that order.
+And the receiver and arguments are nestable.
+
+It is used in QuickCheck and Proper to keep as much history of method calls as possible.
+
 ## Options
 
 ### `-I PATH` or `--include PATH`
@@ -108,6 +125,10 @@ You can specify size of end.
 
 You can specify size of step like `Integer#step: (to: Integer, by: Integer)`.
 
+## 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.
@@ -119,6 +140,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,5 @@
+#!/usr/bin/env ruby
+
 require 'raap'
 
-RaaP::CLI.new(ARGV).load.run
+exit RaaP::CLI.new(ARGV).load.run

data/lib/raap/bind_call.rb

@@ -11,19 +11,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,
@@ -16,197 +11,264 @@ module RaaP
       :size_from,
       :size_to,
       :size_by,
+      :allow_private,
+      :skips,
       keyword_init: true
     )
 
-    # defaults
-    self.option = Option.new(
-      dirs: [],
-      requires: [],
-      libraries: [],
-      timeout: 3,
-      size_from: 0,
-      size_to: 99,
-      size_by: 1,
-    )
+    # 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,
+        skips: [],
+        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|
           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: #{@option.size_from}") do |arg|
+          @option.size_from = arg
+        end
+        o.on('--size-to int', Integer, "default: #{@option.size_to}") do |arg|
+          @option.size_to = arg
         end
-        o.on('--size-from int', Integer, "default: #{CLI.option.size_from}") do |arg|
-          CLI.option.size_from = arg
+        o.on('--size-by int', Integer, "default: #{@option.size_by}") do |arg|
+          @option.size_by = arg
         end
-        o.on('--size-to int', Integer, "default: #{CLI.option.size_to}") do |arg|
-          CLI.option.size_to = arg
+        o.on('--allow-private', "default: #{@option.allow_private}") do
+          @option.allow_private = true
         end
-        o.on('--size-by int', Integer, "default: #{CLI.option.size_by}") do |arg|
-          CLI.option.size_by = arg
+        o.on('--skip tag', "skip case (e.g. `Foo#meth`)") do |tag|
+          @option.skips << tag
         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
+      @option.skips.each do |skip|
+        @skip << skip
+      end
+      @skip.freeze
 
       self
     end
 
     def run
+      Signal.trap(:INT) do
+        puts "Interrupted by SIGINT"
+        report
+        exit 1
+      end
+
       @argv.map do |tag|
         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|
+      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)
+          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|
+        next if @skip.include?("#{type_name.absolute!}.#{method_name}")
         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|
+        next if @skip.include?("#{type_name.absolute!}##{method_name}")
         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_params_decl.each_with_index do |_, i|
+        if rtype.instance_of?(::RBS::Types::ClassInstance)
+          rtype.args[i] = type_args[i] || ::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:,
@@ -215,39 +277,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,
-      ).run do |called|
+        size_step: @option.size_from.step(to: @option.size_to, by: @option.size_by),
+        timeout: @option.timeout,
+        allow_private: true,
+      )
+      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}`"
-          puts
+          if (e = f.exception)
+            RaaP.logger.debug { "Failure: [#{e.class}] #{e.message}" }
+            RaaP.logger.debug { e.backtrace.join("\n") }
+          end
           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("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.info("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

data/lib/raap/function_type.rb

@@ -6,35 +6,39 @@ module RaaP
       @fun = fun
     end
 
-    def pick_arguments(size: 10, eval: true)
-      a = recursive_pick(build_args_type, size:, eval:)
-      k = recursive_pick(build_kwargs_type, size:, eval:)
+    def pick_arguments(size: 10)
+      SymbolicCaller.new(arguments_to_symbolic_call(size:)).eval
+    end
+
+    def arguments_to_symbolic_call(size: 10)
+      a = to_symbolic_call_recursive(build_args_type, size:)
+      k = to_symbolic_call_recursive(build_kwargs_type, size:)
 
       [a, k]
     end
 
     private
 
-    def recursive_pick(type, size:, eval:)
+    def to_symbolic_call_recursive(type, size:)
       case
       when type.nil?
         nil
       when type.respond_to?(:each_pair)
-        type.each_pair.to_h { |k, v| [k, recursive_pick(v, size:, eval:)] }
+        type.each_pair.to_h { |k, v| [k, to_symbolic_call_recursive(v, size:)] }
       when type.respond_to?(:each)
-        type.each.map { |v| recursive_pick(v, size:, eval:) }
+        type.each.map { |v| to_symbolic_call_recursive(v, size:) }
       else
-        type.pick(size:, eval:)
+        type.to_symbolic_call(size:)
       end
     end
 
     def build_args_type
       reqs = @fun.required_positionals.map { |param| Type.new(param.type) }
       tras = @fun.trailing_positionals.map { |param| Type.new(param.type) }
-      sampled_optional_positionals = @fun.optional_positionals.sample(Random.rand(@fun.optional_positionals.length + 1))
+      sampled_optional_positionals = @fun.optional_positionals.take(Random.rand(@fun.optional_positionals.length + 1))
       opts = sampled_optional_positionals.map { |param| Type.new(param.type) }
       rest = []
-      if param = @fun.rest_positionals
+      if (param = @fun.rest_positionals)
         rest = Array.new(Random.rand(0..3)) { Type.new(param.type) }
       end
       [reqs, opts, rest, tras].flatten
@@ -45,7 +49,7 @@ module RaaP
       rand = Random.rand(@fun.optional_keywords.length + 1)
       opts = @fun.optional_keywords.to_a.sample(rand).to_h { |name, param| [name, Type.new(param.type)] }
       kwargs = reqs.to_h.merge(opts)
-      if param = @fun.rest_keywords
+      if (param = @fun.rest_keywords)
         keys = Array.new(Random.rand(0..3)) do
           random_key = nil
           loop do