raap 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5780226ede8755c1ef7f82e18b7e8d96a63d2ab6eb253bc8964f5745776f993f
-  data.tar.gz: 6e9dd39a302f555cac12ecb6232a7c2f39d206911fcee7a30650d5fe4a9cbc63
+  metadata.gz: f119356b79f6beb968f26d019dda506e8eada4a48e178bd029e7e97d187f2d2c
+  data.tar.gz: f72f9d682ff47f11d51ebcf547a7f991c75b9be731eabc018fbb5b5a727dc358
 SHA512:
-  metadata.gz: 2841e75bc0b03742cc0d9268f9ec2ae69f2f9c6e1f579ec6e794db5e9b8f80d763fac4ce28abd7361e19ada8f6289e594b6a9a3cdc63b1806181a69a9f49bb6a
-  data.tar.gz: a3057811c5d13ac4f891fc2c2082b91f33a1a8d35d3c9b6e1ccb1871c268127811caa6f2708c878ef35ae4cc25143db62c4e5801ded32cfad9a1db50387753a6
+  metadata.gz: 7d3fbbfd916eb8526d9021e94408f4af402d80455c89b822c74557a76a31b8fc93a0d7acd8e47efdca32a8b1a19fb37a2b8f997e3c7ad6083e2f61d72052973a
+  data.tar.gz: cfbeb8a13d53e16a6e51701c30354ea1537c8b6b7a7ef46665b7e0efe9db43a4ce769370f38f558e4a384c80a039960faa65acbc8648c8f36e3725a53c2c1075

data/.rubocop.yml

@@ -8,6 +8,8 @@ Lint:
   Enabled: true
 Lint/EmptyBlock:
   Enabled: false
+Lint/SymbolConversion:
+  Enabled: false
 
 Style:
   Enabled: false

data/README.md

@@ -1,6 +1,6 @@
 # RaaP
 
-<img src="https://raw.githubusercontent.com/ksss/raap/main/public/jacket.webp" width=400/>
+<img src="https://raw.githubusercontent.com/ksss/raap/main/public/jacket.webp" width=500/>
 
 ## RBS as a Property
 
@@ -14,6 +14,10 @@ The return value of the method is checked to see if it matches the type, if not,
 
 If you write an RBS, it becomes a test case.
 
+## Example
+
+<img src="https://raw.githubusercontent.com/ksss/raap/main/public/example.webp" width=700/>
+
 ## Concept
 
 If you has next signature.
@@ -53,6 +57,10 @@ Then, you can start loop again.
 
 Finally, you get the perfect RBS!
 
+## Slide
+
+https://speakerdeck.com/ksss/raap
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -88,6 +96,20 @@ $ raap $(cat test/raap.txt)   # You can manage the methods to be tested in a fil
 - info: A somewhat visualized representation of the execution state.
 - debug: All information including stack traces.
 
+## Coverage
+
+RaaP randomly selects a type and generates a value for optional and union types.
+
+By default, displays the coverage of the type that actually produced the value.
+
+The coverage display can help you determine if a correction is needed.
+
+### Meaning of colored types
+
+- 🔴 Red: A type that has never been used to generate or validate a value.
+- 🟡 Yellow: It is systematically difficult to determine if the type was used or not. (FIXME)
+- 🟢 Green: The type used to generate and validate the value.
+
 ## Size
 
 Random values are determined based on size.
@@ -150,6 +172,42 @@ You can specify size of step like `Integer#step: (to: Integer, by: Integer)`.
 By default, raap only validates public methods.
 However, by setting this option, it is possible to intentionally validate private methods in the RBS.
 
+### `--preload path`
+
+Simply call `Kernel.load`.
+However, this simplifies the preliminary preparation.
+
+#### Preload examples
+
+1) Check signature of aws-sdk-s3
+
+```rb
+$ cat preload.rb
+require 'aws-sdk-s3'
+
+# Register initialize of `Aws::S3::Client` class.
+RaaP::Type.register("Aws::S3::Client") do
+  [:call, Aws::S3::Client, :new, [], { stub_responses: true }, nil]
+end
+
+$ raap --preload ./preload.rb 'Aws::S3::Client#get_object'
+```
+
+2) Output ruby coverage by simplecov
+
+```rb
+$ cat preload.rb
+require 'simplecov'
+
+SimpleCov.command_name 'raap'
+SimpleCov.start do
+  enable_coverage :branch
+  add_filter "/test/"
+end
+
+$ bundle exec raap --preload ./preload.rb -r my_class 'MyClass'
+```
+
 ## 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.

data/lib/raap/cli.rb

@@ -12,6 +12,7 @@ module RaaP
       :size_to,
       :size_by,
       :allow_private,
+      :coverage,
       keyword_init: true
     )
 
@@ -37,13 +38,11 @@ module RaaP
     def initialize(argv)
       # defaults
       @option = Option.new(
-        dirs: [],
-        requires: [],
-        libraries: [],
         timeout: 3,
         size_from: 0,
         size_to: 99,
         size_by: 1,
+        coverage: true,
         allow_private: false,
       )
       @argv = argv
@@ -54,13 +53,13 @@ module RaaP
     def load
       OptionParser.new do |o|
         o.on('-I', '--include PATH') do |path|
-          @option.dirs << path
+          RaaP::RBS.loader.add(path: Pathname(path))
         end
         o.on('--library lib', 'load rbs library') do |lib|
-          @option.libraries << lib
+          RaaP::RBS.loader.add(library: lib, version: nil)
         end
         o.on('--require lib', 'require ruby library') do |lib|
-          @option.requires << lib
+          require lib
         end
         o.on('--log-level level', "default: info") do |arg|
           RaaP.logger.level = arg
@@ -80,18 +79,14 @@ module RaaP
         o.on('--allow-private', "default: #{@option.allow_private}") do
           @option.allow_private = true
         end
+        o.on('--preload path', 'Kernel.load path') do |path|
+          Kernel.load path
+        end
+        o.on('--[no-]coverage', "Show coverage for RBS (default: #{@option.coverage})") do |arg|
+          @option.coverage = arg
+        end
       end.parse!(@argv)
 
-      @option.dirs.each do |dir|
-        RaaP::RBS.loader.add(path: Pathname(dir))
-      end
-      @option.libraries.each do |lib|
-        RaaP::RBS.loader.add(library: lib, version: nil)
-      end
-      @option.requires.each do |lib|
-        require lib
-      end
-
       self
     end
 
@@ -300,6 +295,7 @@ module RaaP
         timeout: @option.timeout,
         allow_private: @option.allow_private,
       )
+      RaaP::Coverage.start(method_type) if @option.coverage
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       stats = prop.run do |called|
         case called
@@ -337,6 +333,9 @@ module RaaP
       end
       end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       puts
+      RaaP::Coverage.show($stdout) if @option.coverage
+      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}"

data/lib/raap/coverage.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RaaP
+  module Coverage
+    class Writer
+      def initialize(method_type, cov)
+        @method_type = method_type
+        @cov = cov
+        @cur = 0
+      end
+
+      def write(io)
+        RaaP.logger.debug { "Coverage: #{@cov}" }
+        ml = @method_type.location
+        unless ml
+          RaaP.logger.warn("No location information for `#{@method_type}`")
+          return
+        end
+        if ml.key?(:keyword)
+          # attr_{reader,writer,accessor}
+          phantom_member = RBS.parse_member(ml.source)
+          case phantom_member
+          when ::RBS::AST::Members::Attribute
+            unless phantom_member.location
+              RaaP.logger.warn("No location information for `#{phantom_member}`")
+              return
+            end
+            write_type(io, "return", phantom_member.type)
+            io.write(slice(@cur, @cur...phantom_member.location.end_pos))
+          else
+            RaaP.logger.error("#{phantom_member.class} is not supported")
+            return
+          end
+        else
+          # def name: () -> type
+          phantom_method_type = RBS.parse_method_type(ml.source)
+          phantom_method_type.type.yield_self do |fun|
+            case fun
+            when ::RBS::Types::Function
+              fun.required_positionals.each_with_index { |param, i| write_param(io, "req_#{i}", param) }
+              fun.optional_positionals.each_with_index { |param, i| write_param(io, "opt_#{i}", param) }
+              fun.rest_positionals&.yield_self         { |param| write_param(io, "rest", param) }
+              fun.trailing_positionals.each_with_index { |param, i| write_param(io, "trail_#{i}", param) }
+              fun.required_keywords.each               { |key, param| write_param(io, "keyreq_#{key}", param) }
+              fun.optional_keywords.each               { |key, param| write_param(io, "key_#{key}", param) }
+              fun.rest_keywords&.yield_self            { |param| write_param(io, "keyrest", param) }
+              # when ::RBS::Types::UntypedFunction
+            end
+          end
+
+          phantom_method_type.block&.yield_self do |b|
+            b.type.each_param.with_index { |param, i| write_param(io, "block_param_#{i}", param) }
+            write_type(io, "block_return", b.type.return_type)
+          end
+          write_type(io, "return", phantom_method_type.type.return_type)
+          raise unless phantom_method_type.location
+
+          io.write(slice(@cur, @cur...phantom_method_type.location.end_pos))
+        end
+
+        io.puts
+      end
+
+      private
+
+      def slice(start, range)
+        ml = @method_type.location
+        raise unless ml
+
+        ml.source[start, range.end - range.begin] or raise
+      end
+
+      def write_param(io, position, param)
+        write_type(io, position, param.type)
+      end
+
+      def write_type(io, position, type)
+        unless type.location
+          RaaP.logger.warn("No location information for `#{type}`")
+          return
+        end
+        io.write(slice(@cur, @cur...type.location.start_pos))
+        @cur = type.location.start_pos
+        case type
+        when ::RBS::Types::Tuple, ::RBS::Types::Union
+          name = type.class.name.split('::').last.downcase
+          type.types.each_with_index do |t, i|
+            t.location or raise
+            io.write(slice(@cur, @cur...t.location.start_pos)) # ( or [
+            @cur = t.location.start_pos
+            write_type(io, "#{position}_#{name}_#{i}", t)
+          end
+        when ::RBS::Types::Optional
+          raise unless type.location
+
+          write_type(io, "#{position}_optional_left", type.type)
+          io.write(slice(@cur, @cur...(type.location.end_pos - 1)))
+          @cur = type.location.end_pos - 1
+          if @cov.include?("#{position}_optional_right".to_sym)
+            io.write(green('?'))
+          else
+            io.write(red('?'))
+          end
+          raise unless type.location
+
+          @cur = type.location.end_pos
+        else
+          raise unless type.location
+
+          if @cov.include?(position.to_sym)
+            io.write(green(type.location.source))
+          else
+            io.write(red(type.location.source))
+          end
+          @cur = type.location.end_pos
+        end
+      end
+
+      def green(str) = "\e[32m#{str}\e[0m"
+      def red(str) = "\e[1;4;41m#{str}\e[0m"
+    end
+
+    class << self
+      def start(method_type)
+        @cov = Set.new
+        @method_type = method_type
+      end
+
+      def running?
+        !!@cov
+      end
+
+      def log(position)
+        return unless running?
+
+        cov << position.to_sym
+      end
+
+      def cov
+        @cov or raise("Coverage is not started")
+      end
+
+      def show(io)
+        return unless running?
+
+        writer = Writer.new(@method_type, cov)
+        writer.write(io)
+      end
+
+      def new_type_with_log(position, type)
+        log_with_type(position, type) do |t|
+          Type.new(t)
+        end
+      end
+
+      def log_with_type(position, type, &block)
+        case type
+        when ::RBS::Types::Tuple
+          # FIXME: Support Union in Tuple
+          type.types.each_with_index do |_t, i|
+            log("#{position}_tuple_#{i}")
+          end
+          block&.call(type)
+        when ::RBS::Types::Union
+          i = Random.rand(type.types.length)
+          log_with_type("#{position}_union_#{i}", type.types[i], &block)
+        when ::RBS::Types::Optional
+          if Random.rand(2).zero?
+            log_with_type("#{position}_optional_left", type.type, &block)
+          else
+            log_with_type("#{position}_optional_right", ::RBS::Types::Bases::Nil.new(location: nil), &block)
+          end
+        else
+          log(position)
+          block&.call(type)
+        end
+      end
+    end
+  end
+end

data/lib/raap/function_type.rb

@@ -2,8 +2,9 @@
 
 module RaaP
   class FunctionType
-    def initialize(fun)
+    def initialize(fun, coverage: true)
       @fun = fun
+      @coverage = coverage
     end
 
     def pick_arguments(size: 10)
@@ -26,42 +27,66 @@ module RaaP
       when type.respond_to?(:each_pair)
         type.each_pair.to_h { |k, v| [k, to_symbolic_call_recursive(v, size: size)] }
       when type.respond_to?(:each)
-        type.each.map { |v| to_symbolic_call_recursive(v, size: size) }
+        type.map { |v| to_symbolic_call_recursive(v, size: size) }
       else
         type.to_symbolic_call(size: 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.take(Random.rand(@fun.optional_positionals.length + 1))
-      opts = sampled_optional_positionals.map { |param| Type.new(param.type) }
+      reqs = @fun.required_positionals.map.with_index do |param, i|
+        build_type_with_coverage("req_#{i}", param)
+      end
+
+      take_num = Random.rand(@fun.optional_positionals.length + 1)
+      opts = @fun.optional_positionals.take(take_num).map.each_with_index do |param, i|
+        build_type_with_coverage("opt_#{i}", param)
+      end
+
       rest = []
-      if (param = @fun.rest_positionals)
-        rest = Array.new(Random.rand(0..3)) { Type.new(param.type) }
+      if (rest_param = @fun.rest_positionals)
+        rest = Array.new(Random.rand(4)) do
+          build_type_with_coverage("rest", rest_param)
+        end
+      end
+
+      tras = @fun.trailing_positionals.map.with_index do |param, i|
+        build_type_with_coverage("trail_#{i}", param)
       end
+
       [reqs, opts, rest, tras].flatten
     end
 
     def build_kwargs_type
-      reqs = @fun.required_keywords.transform_values { |param| Type.new(param.type) }
+      reqs = @fun.required_keywords.keys.to_h do |key|
+        [key, build_type_with_coverage("keyreq_#{key}", @fun.required_keywords[key])]
+      end
       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)] }
+      opts = @fun.optional_keywords.to_a.sample(rand).to_h do |key, param|
+        [key, build_type_with_coverage("key_#{key}", param)]
+      end
       kwargs = reqs.to_h.merge(opts)
       if (param = @fun.rest_keywords)
-        keys = Array.new(Random.rand(0..3)) do
+        keys = Array.new(Random.rand(4)) do
           random_key = nil
           loop do
             # @type var random_key: Symbol
             random_key = Type.new("Symbol").pick(size: 6)
             break unless kwargs.key?(random_key)
           end
-          [random_key, Type.new(param.type)]
+          [random_key, build_type_with_coverage("keyrest", param)]
         end
         kwargs.merge!(keys.to_h)
       end
       kwargs
     end
+
+    def build_type_with_coverage(position, param)
+      if @coverage
+        Coverage.new_type_with_log(position, param.type)
+      else
+        Type.new(param.type)
+      end
+    end
   end
 end

data/lib/raap/method_property.rb

@@ -50,7 +50,7 @@ module RaaP
     private
 
     def call(size:, stats:)
-      if @method_type.rbs.type.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) }
+      if @method_type.rbs.type.each_param.find { |param| param.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
@@ -67,8 +67,9 @@ module RaaP
           begin
             return_value = symbolic_caller.eval
           rescue StandardError, NotImplementedError
-            check = [:success]
             return_value = Value::Bottom.new
+            coverage("return", return_value, return_type)
+            check = [:success]
           rescue Timeout::ExitException
             raise
           rescue Exception => e # rubocop:disable Lint/RescueException
@@ -113,6 +114,7 @@ module RaaP
         if BindCall.is_a?(return_type, ::RBS::Types::ClassSingleton)
           # ::RBS::Test::TypeCheck cannot support to check singleton class
           if receiver_value == return_value
+            coverage("return", return_value, return_type)
             [:success]
           else
             [:failure]
@@ -135,6 +137,7 @@ module RaaP
       )
       begin
         if type_check.value(return_value, return_type)
+          coverage("return", return_value, return_type, type_check)
           [:success]
         else
           [:failure]
@@ -148,5 +151,33 @@ module RaaP
     def return_type
       @method_type.rbs.type.return_type
     end
+
+    def coverage(position, return_value, return_type, type_check = nil)
+      return unless Coverage.running?
+
+      case return_type
+      when ::RBS::Types::Tuple
+        return_type.types.zip(return_value).each_with_index do |(type, value), i|
+          if type_check&.value(value, type)
+            coverage("#{position}_tuple_#{i}", value, type, type_check)
+          end
+        end
+      when ::RBS::Types::Union
+        return_type.types.each_with_index do |type, i|
+          if type_check&.value(return_value, type)
+            coverage("#{position}_union_#{i}", return_value, type, type_check)
+            break
+          end
+        end
+      when ::RBS::Types::Optional
+        if return_value.nil?
+          Coverage.log("#{position}_optional_right")
+        else
+          coverage("#{position}_optional_left", return_value, return_type.type, type_check)
+        end
+      else
+        Coverage.log(position)
+      end
+    end
   end
 end

data/lib/raap/method_type.rb

@@ -19,9 +19,17 @@ module RaaP
 
       params = (type_params_decl + rbs.type_params).uniq
       ts = TypeSubstitution.new(params, type_args)
-
       @rbs = ts.method_type_sub(rbs, self_type: self_type, instance_type: instance_type, class_type: class_type)
-      @fun_type = FunctionType.new(@rbs.type)
+      function_or_untypedfunction = __skip__ = @rbs.type
+      @fun_type = FunctionType.new(function_or_untypedfunction)
+      @type_check = ::RBS::Test::TypeCheck.new(
+        self_class: (_ = self_type),
+        instance_class: (_ = instance_type),
+        class_class: (_ = class_type),
+        builder: RBS.builder,
+        sample_size: 100,
+        unchecked_classes: []
+      )
     end
 
     def pick_arguments(size: 10)
@@ -40,21 +48,63 @@ module RaaP
       return nil if block.nil?
       return nil if (block.required == false) && [true, false].sample
 
+      args_name = []
+      args_source = []
+      resource = [*'a'..'z']
+      case fun = block.type
+      when ::RBS::Types::Function
+        # FIXME: Support keyword types
+        fun.required_positionals.each do
+          resource.shift.tap do |name|
+            args_name << name
+            args_source << name
+          end
+        end
+        fun.optional_positionals.each do |param|
+          resource.shift.tap do |name|
+            # FIXME: Support without literal type
+            default = Type.new(param.type).pick(size: size)
+            args_name << name
+            args_source << "#{name} = #{default}"
+          end
+        end
+        fun.rest_positionals&.yield_self do |_|
+          resource.shift.tap do |name|
+            args_name << "*#{name}"
+            args_source << "*#{name}"
+          end
+        end
+        fun.trailing_positionals.each do
+          resource.shift.tap do |name|
+            args_name << name
+            args_source << name
+          end
+        end
+      end
+      # Hack: Use local variable in eval
       fixed_return_value = Type.new(block.type.return_type).pick(size: size)
-      Proc.new { fixed_return_value }
+      _ = fixed_return_value
+      type_check = @type_check
+      _ = type_check
+      eval(<<~RUBY) # rubocop:disable Security/Eval
+        -> (#{args_source.join(', ')}) do
+          i = 0
+          type_check.zip_args([#{args_name.join(', ')}], block.type) do |val, param|
+            unless type_check.value(val, param.type)
+              raise TypeError, "block argument type mismatch: expected `(\#{fun.param_to_s})`, got \#{BindCall.inspect([#{args_name.join(', ')}])}"
+            end
+
+            Coverage.log_with_type("block_param_\#{i}", param.type)
+            i += 1
+          end
+          Coverage.log_with_type("block_return", block.type.return_type)
+          fixed_return_value
+        end
+      RUBY
     end
 
     def check_return(return_value)
-      untyped = __skip__ = nil
-      type_check = ::RBS::Test::TypeCheck.new(
-        self_class: untyped,     # cannot support `self`
-        instance_class: untyped, # cannot support `instance`
-        class_class: untyped,    # cannot support `class`
-        builder: RBS.builder,
-        sample_size: 100,
-        unchecked_classes: []
-      )
-      type_check.value(return_value, rbs.type.return_type)
+      @type_check.value(return_value, rbs.type.return_type)
     end
   end
 end

data/lib/raap/rbs.rb

@@ -26,6 +26,48 @@ module RaaP
       ::RBS::Parser.parse_method_type(method_type, require_eof: true) or raise
     end
 
+    def self.parse_member(member_type)
+      _, _, decls = ::RBS::Parser.parse_signature(<<~RBS)
+        module MemberScope
+          #{member_type}
+        end
+      RBS
+      decl = decls.first or raise
+      raise unless decl.is_a?(::RBS::AST::Declarations::Module)
+
+      member = decl.members.first or raise
+      raise unless member.is_a?(::RBS::AST::Members::Attribute)
+
+      member.tap do |m|
+        m = __skip__ = m
+        _shift_location(m.type, -m.location.start_pos)
+        _shift_location(m, -m.location.start_pos)
+      end
+    end
+
+    def self._shift_location(localable, shift)
+      return if localable.location.nil?
+
+      l = localable.instance_variable_get("@location")
+      localable.instance_variable_set(
+        "@location",
+        ::RBS::Location.new(
+          buffer: ::RBS::Buffer.new(
+            name: l.buffer.name,
+            content: l.buffer.content[-shift..l.end_pos],
+          ),
+          start_pos: l.start_pos + shift,
+          end_pos: l.end_pos + shift,
+        )
+      )
+      case localable
+      when ::RBS::Types::Union
+        localable.types.each { |t| _shift_location(t, shift) }
+      when ::RBS::Types::Optional
+        _shift_location(localable.type, shift)
+      end
+    end
+
     def self.find_alias_decl(type_name, method_name)
       env.class_decls[type_name].decls.each do |d|
         d.decl.members.each do |member|

data/lib/raap/type.rb

@@ -24,6 +24,7 @@ module RaaP
     def self.register(type_name, &block)
       raise ArgumentError, "block is required" unless block
 
+      type_name = "::#{type_name}" if !type_name.start_with?("::")
       GENERATORS[type_name] = __skip__ = block
     end
 
@@ -69,11 +70,12 @@ module RaaP
       t = instance.args[0] ? Type.new(instance.args[0], range: range) : Type.random
       array(t)
     end
-    register("::Binding") { sized { binding } }
+    register("::Binding") { binding }
     register("::Complex") { complex }
-    register("::Data") { sized { Data.define } }
+    register("::Data") { Data.define }
     register("::Encoding") { encoding }
-    register("::FalseClass") { sized { false } }
+    register("::FalseClass") { false }
+    register("::File") { File.open("/dev/null") }
     register("::Float") { float }
     register("::Hash") do
       instance = __skip__ = type
@@ -82,18 +84,18 @@ module RaaP
       dict(key, value)
     end
     register("::Integer") { integer }
-    register("::IO") { sized { $stdout } }
-    register("::Method") { sized { temp_method_object } }
-    register("::NilClass") { sized { nil } }
-    register("::Proc") { sized { Proc.new {} } }
+    register("::IO") { $stdout }
+    register("::Method") { temp_method_object }
+    register("::NilClass") { nil }
+    register("::Proc") { Proc.new {} }
     register("::Rational") { rational }
     register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
     register("::String") { string }
-    register("::Struct") { sized { Struct.new(:foo, :bar).new } }
+    register("::Struct") { Struct.new(:foo, :bar).new }
     register("::Symbol") { symbol }
-    register("::Time") { sized { [:call, Time, :now, [], {}, nil] } }
-    register("::TrueClass") { sized { true } }
-    register("::UnboundMethod") { sized { temp_method_object.unbind } }
+    register("::Time") { [:call, Time, :now, [], {}, nil] }
+    register("::TrueClass") { true }
+    register("::UnboundMethod") { temp_method_object.unbind }
 
     attr_reader :type
     attr_reader :range
@@ -176,7 +178,7 @@ module RaaP
         Object.const_get(type.name.to_s)
       when ::RBS::Types::ClassInstance
         case gen = GENERATORS[type.name.absolute!.to_s]
-        in Proc then instance_exec(&gen).pick(size: size)
+        in Proc then pick_by_generator(gen, size: size)
         in nil then to_symbolic_call_from_initialize(type, size: size)
         end
       when ::RBS::Types::Record
@@ -186,7 +188,7 @@ module RaaP
       when ::RBS::Types::Literal
         type.literal
       when ::RBS::Types::Bases::Bool
-        bool.pick(size: size)
+        bool
       when ::RBS::Types::Bases::Any
         Type.random.to_symbolic_call(size: size)
       when ::RBS::Types::Bases::Nil
@@ -198,6 +200,16 @@ module RaaP
 
     private
 
+    def pick_by_generator(gen, size:)
+      ret = instance_exec(&gen)
+      case ret
+      when Sized
+        ret.pick(size: size)
+      else
+        ret
+      end
+    end
+
     def to_symbolic_call_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
@@ -301,16 +313,12 @@ module RaaP
     end
 
     def encoding
-      sized do
-        e = Encoding.list.sample or raise
-        [:call, Encoding, :find, [e.name], {}, nil]
-      end
+      e = Encoding.list.sample or raise
+      [:call, Encoding, :find, [e.name], {}, nil]
     end
 
     def bool
-      sized do
-        Random.rand(2) == 0
-      end
+      Random.rand(2) == 0
     end
 
     def temp_method_object

data/lib/raap/type_substitution.rb

@@ -25,6 +25,10 @@ module RaaP
       instance_type = instance_type.is_a?(::String) ? RBS.parse_type(instance_type) : instance_type
       class_type = class_type.is_a?(::String) ? RBS.parse_type(class_type) : class_type
       sub = build
+      if sub.empty? && self_type.nil? && instance_type.nil? && class_type.nil?
+        return method_type
+      end
+
       ::RBS::MethodType.new(
         type_params: [],
         type: method_type.type.sub(sub).then { |ty| sub(ty, self_type: self_type, instance_type: instance_type, class_type: class_type) },

data/lib/raap/value/interface.rb

@@ -2,9 +2,9 @@
 
 module RaaP
   module Value
-    class Interface < BasicObject
+    class Interface
       class << self
-        def define_method_from_interface(base_class, type, size: 3)
+        def define_method_from_interface(base_mod, type, size: 3)
           type = type.is_a?(::String) ? RBS.parse_type(type) : type
           unless type.instance_of?(::RBS::Types::Interface)
             ::Kernel.raise ::TypeError, "not an interface type: #{type}"
@@ -22,7 +22,7 @@ module RaaP
             ts = TypeSubstitution.new(type_params, type.args)
             subed_method_type = ts.method_type_sub(method_type, self_type: self_type, instance_type: instance_type, class_type: class_type)
 
-            BindCall.define_method(base_class, name) do |*_, &b|
+            BindCall.define_method(base_mod, name) do |*_, &b|
               @fixed_return_value ||= {}
               @fixed_return_value[name] ||= if self_type == subed_method_type.type.return_type
                                               self
@@ -30,16 +30,13 @@ module RaaP
                                               Type.new(subed_method_type.type.return_type).pick(size: size)
                                             end
               # @type var b: Proc?
-              if b
+              if b && subed_method_type.block && subed_method_type.block.type.is_a?(::RBS::Types::Function)
                 @fixed_block_arguments ||= {}
-                @fixed_block_arguments[name] ||= if subed_method_type.block
-                                                   size.times.map do
-                                                     FunctionType.new(subed_method_type.block.type)
-                                                                 .pick_arguments(size: size)
-                                                   end
-                                                 else
-                                                   []
-                                                 end
+                @fixed_block_arguments[name] ||= size.times.map do
+                  FunctionType.new(subed_method_type.block.type, coverage: false)
+                              .pick_arguments(size: size)
+                end
+
                 @fixed_block_arguments[name].each do |a, kw|
                   b.call(*a, **kw)
                 end
@@ -68,14 +65,6 @@ module RaaP
         @size = size
       end
 
-      def respond_to?(name, _include_all = false)
-        @definition.methods.has_key?(name.to_sym)
-      end
-
-      def class
-        Interface
-      end
-
       def inspect
         "#<interface @type=`#{@type}` @methods=#{@definition.methods.keys} @size=#{@size}>"
       end

data/lib/raap/value/intersection.rb

@@ -17,19 +17,18 @@ module RaaP
           raise ArgumentError, "intersection type must have at least one class instance type in `#{instances}`"
         end
 
-        base = instances.find { |c| c.is_a?(::Class) } || BasicObject
+        base = instances.find { |c| c.is_a?(::Class) } || Object
 
         c = Class.new(base) do
           instances.select { |i| !i.is_a?(::Class) }.each do |m|
             include(m)
           end
 
-          interfaces = type.types.select do |t|
-            t.instance_of?(::RBS::Types::Interface)
-          end
-
-          interfaces.each do |interface|
-            Interface.define_method_from_interface(self, interface, size: size)
+          type.types.each do |t|
+            case t
+            when ::RBS::Types::Interface
+              Interface.define_method_from_interface(self, t, size: size)
+            end
           end
         end
         type = ::RBS::Types::ClassInstance.new(name: TypeName(base.name), args: [], location: nil)

data/lib/raap/value/variable.rb

@@ -2,7 +2,7 @@
 
 module RaaP
   module Value
-    class Variable < BasicObject
+    class Variable
       attr_reader :type
 
       def initialize(type)

data/lib/raap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RaaP
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end

data/lib/raap.rb

@@ -23,6 +23,7 @@ module RaaP
 
   autoload :BindCall, "raap/bind_call"
   autoload :CLI, "raap/cli"
+  autoload :Coverage, "raap/coverage"
   autoload :FunctionType, "raap/function_type"
   autoload :MethodProperty, "raap/method_property"
   autoload :MethodType, "raap/method_type"

data/sig/raap.rbs

@@ -19,21 +19,15 @@ module RaaP
 
   class CLI
     class Option < ::Struct[untyped]
-      def self.new: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool) -> instance
+      def self.new: (?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance
 
-      def self.[]: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool) -> instance
+      def self.[]: (?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance
 
       def self.keyword_init?: () -> true
 
-      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
+      def self.members: () -> [ :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
 
-      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
-
-      attr_accessor dirs: ::Array[String]
-
-      attr_accessor requires: ::Array[String]
-
-      attr_accessor libraries: ::Array[String]
+      def members: () -> [ :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
 
       attr_accessor timeout: (Integer | Float | nil)
 
@@ -44,6 +38,8 @@ module RaaP
       attr_accessor size_by: ::Integer
 
       attr_accessor allow_private: bool
+
+      attr_accessor coverage: bool
     end
 
     type property_result = [Integer, Symbol, ::RBS::MethodType, StringIO?]
@@ -71,10 +67,44 @@ module RaaP
     def report: () -> Integer
   end
 
+  module Coverage
+    type locs = [::RBS::Buffer::loc, ::RBS::Buffer::loc]
+    class Writer
+      @method_type: ::RBS::MethodType
+      @cov: ::Set[Symbol]
+      @cur: Integer
+
+      def initialize: (::RBS::MethodType, Set[Symbol]) -> void
+      def write: (IO) -> void
+
+      private
+
+      def method_type_location: () -> ::RBS::Location[untyped, untyped]
+      def slice: (Integer, Range[Integer]) -> String
+      def write_param: (IO, String, ::RBS::Types::Function::Param) -> void
+      def write_type: (IO, String, ::RBS::Types::t) -> void
+      def green: (String) -> String
+      def red: (String) -> String
+    end
+
+    self.@cov: Set[Symbol]?
+    self.@method_type: ::RBS::MethodType
+
+    def self.start: (::RBS::MethodType) -> void
+    def self.running?: () -> bool
+    def self.log: (String | Symbol) -> void
+    def self.cov: () -> Set[Symbol]
+    def self.show: (IO) -> void
+    def self.new_type_with_log: (String, ::RBS::Types::t) -> Type
+    def self.log_with_type: (String, ::RBS::Types::t) -> nil
+                          | (String, ::RBS::Types::t) ?{ (::RBS::Types::t) -> Type } -> Type
+  end
+
   class FunctionType
     @fun: ::RBS::Types::Function
+    @coverage: boolish
 
-    def initialize: (::RBS::Types::Function) -> void
+    def initialize: (::RBS::Types::Function, ?coverage: boolish) -> void
     def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
     def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
 
@@ -83,6 +113,7 @@ module RaaP
     def to_symbolic_call_recursive: (untyped, size: Integer) -> untyped
     def build_args_type: () -> Array[Type]
     def build_kwargs_type: () -> Hash[Symbol, Type]
+    def build_type_with_coverage: (String, ::RBS::Types::Function::Param) -> Type
   end
 
   class MethodProperty
@@ -108,11 +139,14 @@ module RaaP
     def call: (size: Integer, stats: Stats) -> (Result::Success | Result::Failure | Result::Skip | Result::Exception)
     def check_return: (receiver_value: untyped, return_value: untyped) -> ([Symbol] | [Symbol, Exception])
     def return_type: () -> RBS::Types::t
+    def original_return_type: () -> RBS::Types::t
+    def coverage: (String, untyped, RBS::Types::t, ?RBS::Test::TypeCheck?) -> void
   end
 
   class MethodType
     attr_reader rbs: ::RBS::MethodType
     @fun_type: FunctionType
+    @type_check: ::RBS::Test::TypeCheck
 
     def initialize: (::RBS::MethodType | String method, ?type_params_decl: Array[untyped], ?type_args: Array[untyped], ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> void
     def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
@@ -134,6 +168,8 @@ module RaaP
     def self.loader: () -> ::RBS::EnvironmentLoader
     def self.parse_type: (String) -> ::RBS::Types::t
     def self.parse_method_type: (String) -> ::RBS::MethodType
+    def self.parse_member: (String) -> ::RBS::AST::Members::Attribute
+    def self._shift_location: (untyped, Integer) -> void
     def self.find_alias_decl: (::RBS::TypeName, Symbol) -> ::RBS::AST::Members::Alias?
   end
 
@@ -242,7 +278,7 @@ module RaaP
     GENERATORS: Hash[String, ^() -> Sized[untyped]]
     SIMPLE_SOURCE: Array[String]
 
-    def self.register: (String) { () [self: instance] -> Sized[untyped] } -> void
+    def self.register: (String) { () [self: instance] -> untyped } -> void
     def self.random: () -> Type
     def self.random_without_basic_object: () -> Type
     def self.call_new_from: (Module, ::RBS::Types::ClassInstance, size: Integer) -> symbolic_call
@@ -278,8 +314,8 @@ module RaaP
     def symbol: () -> Sized[Symbol]
     def array: (Type) -> Sized[Array[untyped]]
     def dict: (Type, Type) -> Sized[Hash[untyped, untyped]]
-    def encoding: () -> Sized[symbolic_call]
-    def bool: () -> Sized[bool]
+    def encoding: () -> symbolic_call
+    def bool: () -> bool
     def temp_method_object: () -> ::Method
   end
 
@@ -289,19 +325,19 @@ module RaaP
       def class: () -> class
     end
 
-    class Interface < BasicObject
+    class Interface
       @type: ::RBS::Types::Interface
       @size: Integer
       @definition: ::RBS::Definition
 
-      def self.define_method_from_interface: (Class base_class, String | ::RBS::Types::Interface type, ?size: Integer) -> void
+      def self.define_method_from_interface: (::Module base_class, String | ::RBS::Types::Interface type, ?size: Integer) -> void
       def initialize: (String | ::RBS::Types::Interface | String, ?size: Integer) -> void
       def respond_to?: (Symbol, ?boolish) -> bool
       def inspect: () -> String
       def class: () -> class
     end
 
-    class Intersection < BasicObject
+    module Intersection
       @type: ::RBS::Types::Intersection
       @children: Array[Type]
       @size: Integer
@@ -328,7 +364,7 @@ module RaaP
       def class: () -> class
     end
 
-    class Variable < BasicObject
+    class Variable
       attr_reader type: ::RBS::Types::Variable
 
       def initialize: (::RBS::Types::Variable | String | Symbol) -> void

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-25 00:00:00.000000000 Z
+date: 2024-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -57,6 +57,7 @@ files:
 - lib/raap.rb
 - lib/raap/bind_call.rb
 - lib/raap/cli.rb
+- lib/raap/coverage.rb
 - lib/raap/function_type.rb
 - lib/raap/method_property.rb
 - lib/raap/method_type.rb
@@ -77,6 +78,7 @@ files:
 - lib/raap/value/void.rb
 - lib/raap/version.rb
 - lib/shims.rb
+- public/example.webp
 - public/jacket.webp
 - rbs_collection.lock.yaml
 - rbs_collection.yaml
@@ -102,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: RBS as a Property