raap 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e9d7ac0f6d02b3bc1dce9ad5d49d47d0b73825cfdb60a9e2a9f60a7ab0538a4
-  data.tar.gz: 5e4204d5ce36b5b271ff715ad460533e27edd625c7e2b9a075d8d4e6db4ff6e0
+  metadata.gz: 507ed156280ed3e0db1f2eb454bb03c57aa473d537d8c6ea5905ad852eba550d
+  data.tar.gz: 3108fa50c664702f79141a3c0b5e83934d6742468d1d51bfb2febb5b64a00b12
 SHA512:
-  metadata.gz: cd12a1a50335e228a4700dd048d66f835a0963b4dd7373a890c02c9975d1587c9929604d18b6ce51a1696ce67c3b15c9d9f2d06f76aa22e9a9f6f467c8ee3fbb
-  data.tar.gz: f1cb139f0169359bda70f3cbaa03db45f110941d7559531d4f5c02cc8c04ec477f22effb293a6e64db90218101069a9084255d4b75cf64aa0403af20cc4f910b
+  metadata.gz: 269e220d72b9861881de860a71a2adff318105595880fe73e86492e255c9bb32fbeff7ac3685b83ea11d792a02b1509eb969d9956483a9415608530a3f8806bd
+  data.tar.gz: df4e40973681eb292d7844aa5ed1427b7155f619c6ebea53792149f430ab28e42a0a0f52df9517a3af9af1e08494eaccdd8d4d84313c9d24184f6403a51e1dc5

data/README.md

@@ -12,17 +12,54 @@ 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.
 
-## Installation
+## Concept
+
+If you has next signature.
+
+```rbs
+class Foo
+end
+
+class Bar
+  def initialize: (foo: Foo) -> void
+  def f2s: (Float) -> String
+end
+```
+
+Then, RaaP run next testing code automaticaly.
+
+```rb
+describe Bar do
+  let(:foo) { Foo.new }
+  let(:bar) { Bar.new(foo: foo) }
+
+  it "#f2s" do
+    100.times do |size|
+      float = Random.rand * size
+      expect(bar.f2s(float)).to be_a(String)
+    end
+  end
+end
+```
+
+If you got a failure?
+
+- Fix RBS
+- Fix implementation of `Bar#f2s`
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Then, you can start loop again.
+
+Finally, you get the perfect RBS!
+
+## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ bundle add raap
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ gem install raap
 
 ## Usage
 
@@ -41,6 +78,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`

data/lib/raap/bind_call.rb

@@ -8,6 +8,7 @@ module RaaP
       def extend(...) = ::Kernel.instance_method(:extend).bind_call(...)
       def name(...) = ::Module.instance_method(:name).bind_call(...)
       def to_s(...) = ::Kernel.instance_method(:to_s).bind_call(...)
+      def public_send(...) = ::Kernel.instance_method(:public_send).bind_call(...)
 
       def class(obj)
         if respond_to?(obj, :class)

data/lib/raap/cli.rb

@@ -16,6 +16,7 @@ module RaaP
       :size_from,
       :size_to,
       :size_by,
+      :allow_private,
       keyword_init: true
     )
 
@@ -28,6 +29,7 @@ module RaaP
       size_from: 0,
       size_to: 99,
       size_by: 1,
+      allow_private: false,
     )
 
     def initialize(argv)
@@ -60,6 +62,9 @@ module RaaP
         o.on('--size-by int', Integer, "default: #{CLI.option.size_by}") do |arg|
           CLI.option.size_by = arg
         end
+        o.on('--allow-private', "default: #{CLI.option.allow_private}") do
+          CLI.option.allow_private = true
+        end
       end.parse!(@argv)
 
       CLI.option.dirs.each do |dir|
@@ -103,7 +108,11 @@ module RaaP
 
     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)
@@ -121,7 +130,11 @@ module RaaP
 
     def run_by_singleton(tag:)
       t, m = tag.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})")
       method_name = m.to_sym
       definition = RBS.builder.build_singleton(type.name)
@@ -150,6 +163,8 @@ module RaaP
 
     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 = []
@@ -157,6 +172,7 @@ module RaaP
       definition = RBS.builder.build_singleton(type_name)
       type_params_decl = definition.type_params_decl
       definition.methods.filter_map do |method_name, method|
+        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}"
@@ -169,6 +185,7 @@ module RaaP
       definition = RBS.builder.build_instance(type_name)
       type_params_decl = definition.type_params_decl
       definition.methods.filter_map do |method_name, method|
+        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}"
@@ -182,12 +199,13 @@ module RaaP
     end
 
     def property(receiver_type:, type_params_decl:, 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 = receiver_type.type.args
+        type_args = rtype.args
       end
       puts "## def #{prefix}#{method_name}: #{method_type}"
       status = 0
@@ -198,23 +216,27 @@ module RaaP
           method_type,
           type_params_decl:,
           type_args:,
-          self_type: receiver_type.type,
-          instance_type: ::RBS::Types::ClassInstance.new(name: receiver_type.type.name, args: type_args, location: nil),
-          class_type: ::RBS::Types::ClassSingleton.new(name: receiver_type.type.name, location: nil),
+          self_type: rtype,
+          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|
         case called
         in Result::Success => s
-          RaaP.logger.debug { "Success: #{s.called_str}" }
           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}" }
+          end
           puts
           RaaP.logger.debug { PP.pp(f.symbolic_call, ''.dup) }
-          puts "# call stack:"
+          puts "### call stack:"
           puts
           puts "```"
           puts SymbolicCaller.new(f.symbolic_call).to_lines.join("\n")
@@ -223,10 +245,14 @@ module RaaP
           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(s.exception.backtrace.join("\n"))
         in Result::Exception => e
-          RaaP.logger.info("#{e.exception.class}: #{e.exception.message}")
-          RaaP.logger.debug(e.exception.backtrace.join("\n"))
           print 'E'
+          RaaP.logger.debug { PP.pp(e.symbolic_call, ''.dup) }
+          RaaP.logger.debug("Exception: [#{e.exception.class}] #{e.exception.message}")
+          RaaP.logger.debug(e.exception.backtrace.join("\n"))
         end
       end
       puts

data/lib/raap/method_property.rb

@@ -8,25 +8,17 @@ module RaaP
       end
     end
 
-    attr_reader :receiver_type
-    attr_reader :method_name
-    attr_reader :method_type
-    attr_reader :size_step
-    attr_reader :timeout
-
-    def initialize(receiver_type:, method_name:, method_type:, size_step:, timeout:)
+    def initialize(receiver_type:, method_name:, method_type:, size_step:, timeout:, allow_private: false)
       @receiver_type = receiver_type
       @method_name = method_name
       @method_type = method_type
       @size_step = size_step
       @timeout = timeout
+      @allow_private = allow_private
     end
 
     def run
       stats = Stats.new
-      if receiver_type.type.to_s == 'String' && method_name == :initialize
-        return stats
-      end
       begin
         Timeout.timeout(@timeout) do
           catch(:break) do
@@ -44,47 +36,53 @@ module RaaP
     private
 
     def call(size:, stats:)
-      receiver_value = receiver_type.pick(size: size, eval: false)
-      arguments = method_type.pick_arguments(size: size, eval: false)
-      method_value = MethodValue.new(receiver_value:, arguments:, method_name:, size:)
-      symbolic_call = method_value.to_symbolic_call
-      check = false
-      if return_type.instance_of?(::RBS::Types::Bases::Bottom)
-        begin
-          return_value = SymbolicCaller.new(symbolic_call).eval
-        rescue => e
-          check = true
-          return_value = Value::Bottom.new
+      receiver_value = @receiver_type.pick(size: size, eval: false)
+      args, kwargs, block = @method_type.pick_arguments(size: size, eval: false)
+      # @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
+        check = false
+        if return_type.instance_of?(::RBS::Types::Bases::Bottom)
+          begin
+            return_value = symbolic_caller.eval
+          rescue StandardError, NotImplementedError
+            check = true
+            return_value = Value::Bottom.new
+          end
+        else
+          return_value = symbolic_caller.eval
+          check = check_return(receiver_value:, return_value:, method_type: @method_type)
         end
-      else
-        return_value = SymbolicCaller.new(symbolic_call).eval
-        check = check_return(receiver_value:, return_value:, method_type:)
-      end
-      if check
-        stats.success += 1
-        Result::Success.new(method_value:, return_value:)
-      else
-        Result::Failure.new(method_value:, return_value:, symbolic_call:)
+        if check
+          stats.success += 1
+          Result::Success.new(symbolic_call:, return_value:)
+        else
+          Result::Failure.new(symbolic_call:, return_value:)
+        end
+      rescue TypeError => exception
+        Result::Failure.new(symbolic_call:, return_value:, exception:)
       end
+
+    # not ensure symbolic_call
     rescue NoMethodError => exception
       stats.skip += 1
-      Result::Skip.new(method_value:, exception:)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue NameError => e
       msg = e.name.nil? ? '' : "for `#{BindCall.to_s(e.receiver)}::#{e.name}`"
       RaaP.logger.error("Implementation is not found #{msg} maybe.")
       throw :break
     rescue NotImplementedError => exception
       stats.skip += 1
-      Result::Skip.new(method_value:, exception:)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue SystemStackError => exception
       stats.skip += 1
       RaaP.logger.warn "Found recursive type definition."
-      Result::Skip.new(method_value: nil, exception:)
-    rescue TypeError => exception
-      Result::Failure.new(method_value:, return_value:, symbolic_call:)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue => exception
       stats.exception += 1
-      Result::Exception.new(method_value:, exception:)
+      Result::Exception.new(symbolic_call:, exception:)
     end
 
     def check_return(receiver_value:, return_value:, method_type:)
@@ -104,7 +102,7 @@ module RaaP
         instance_class: instance_class,
         class_class: Module,
         builder: RBS.builder,
-        sample_size: 1,
+        sample_size: 100,
         unchecked_classes: []
       )
       begin
@@ -116,7 +114,7 @@ module RaaP
     end
 
     def return_type
-      method_type.rbs.type.return_type
+      @method_type.rbs.type.return_type
     end
   end
 end

data/lib/raap/method_type.rb

@@ -36,5 +36,18 @@ module RaaP
 
       Proc.new { Type.new(block.type.return_type).pick(size:, eval:) }
     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)
+    end
   end
 end

data/lib/raap/minitest.rb

@@ -0,0 +1,35 @@
+require 'minitest'
+
+module RaaP
+  module Minitest
+    def forall(*types, size_step: 0...100)
+      # @type self: Minitest::Test
+
+      if types.length == 1 && types.first.instance_of?(String) && types.first.start_with?("(")
+        # forall("(Integer) -> String") { |int| Foo.new.int2str(int) }
+        type = types.first
+        method_type = RaaP::MethodType.new(type)
+        size_step.each do |size|
+          # TODO assert_send_type
+          args, kwargs, _block = method_type.pick_arguments(size: size)
+          return_value = yield(*args, **kwargs)
+          assert method_type.check_return(return_value), "return value: #{BindCall.inspect(return_value)}[#{BindCall.class(return_value)}] is not match with `#{method_type.rbs.type.return_type}`"
+        end
+      else
+        # forall("Integer", "String") { |int, str| Foo.new.int_str(int, str) }
+        types.map! do |type|
+          case type
+          in String then RaaP::Type.new(type)
+          else type
+          end
+        end
+        size_step.each do |size|
+          values = types.map { |type| type.pick(size: size) }
+          assert yield(*values)
+        end
+      end
+    end
+  end
+end
+
+Minitest::Test.include RaaP::Minitest

data/lib/raap/result.rb

@@ -4,15 +4,20 @@ module RaaP
   module Result
     module CalledStr
       def called_str
-        "#{method_value.call_str} -> #{return_value.inspect}[#{return_value.class}]"
+        scr = SymbolicCaller.new(symbolic_call)
+        "#{scr.call_str} -> #{return_value.inspect}[#{return_value.class}]"
       end
     end
 
-    Success = Data.define(:method_value, :return_value)
+    Success = Data.define(:symbolic_call, :return_value)
     Success.include CalledStr
-    Failure = Data.define(:method_value, :return_value, :symbolic_call)
+    Failure = Data.define(:symbolic_call, :return_value, :exception) do
+      def initialize(exception: nil, **)
+        super
+      end
+    end
     Failure.include CalledStr
-    Skip = Data.define(:method_value, :exception)
-    Exception = Data.define(:method_value, :exception)
+    Skip = Data.define(:symbolic_call, :exception)
+    Exception = Data.define(:symbolic_call, :exception)
   end
 end

data/lib/raap/symbolic_caller.rb

@@ -16,10 +16,27 @@ module RaaP
   # c = C.new(a: a, b: b)
   # c.run() { }
   class SymbolicCaller
+    class Var
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+
+      def +(other)
+        "#{self}#{other}"
+      end
+
+      def to_s
+        @name
+      end
+    end
+
     attr_reader :symbolic_call
+    attr_reader :allow_private
 
-    def initialize(symbolic_call)
+    def initialize(symbolic_call, allow_private: false)
       @symbolic_call = symbolic_call
+      @allow_private = allow_private
     end
 
     def eval
@@ -28,8 +45,18 @@ module RaaP
       end
     end
 
-    def walk(&)
-      _walk(@symbolic_call, &)
+    def call_str
+      symbolic_call => [:call, receiver, Symbol => method_name, Array => args, Hash => kwargs, b]
+      receiver = try_eval(receiver)
+      args, kwargs, block = try_eval([args, kwargs, block])
+
+      a = []
+      a << args.map(&:inspect).join(', ') if !args.empty?
+      a << kwargs.map { |k ,v| "#{k}: #{BindCall.inspect(v)}" }.join(', ') if !kwargs.empty?
+      argument_str = a.join(', ')
+      block_str = block ? "{ }" : nil
+
+      "#{BindCall.inspect(receiver)}.#{method_name}(#{argument_str})#{block_str}"
     end
 
     def to_lines
@@ -39,19 +66,22 @@ module RaaP
 
           is_mod = receiver_value.is_a?(Module)
 
-          if receiver_value == Kernel
-            var = "#{var_name(method_name)} = "
+          case
+          when receiver_value == Kernel
+            var = Var.new(method_name.to_s.downcase)
+            var_eq = "#{var} = "
             receiver = ''
-          elsif is_mod
-            var = "#{var_name(receiver_value)} = "
+          when BindCall.instance_of?(receiver_value, Var)
+            var_eq = ""
+            var = Var.new(receiver_value.name)
+            receiver = var + '.'
+          when is_mod
+            var = Var.new(var_name(receiver_value))
+            var_eq = "#{var} = "
             receiver = receiver_value.name + '.'
           else
-            var = ""
-            receiver = if printable?(receiver_value)
-              printable(receiver_value) + '.'
-            else
-              var_name(receiver_value.class) + '.'
-            end
+            var_eq = ""
+            receiver = Var.new(printable(receiver_value)) + '.'
           end
 
           arguments = []
@@ -59,15 +89,25 @@ module RaaP
           arguments << kwargs.map{|k,v| "#{k}: #{printable(v)}" }.join(', ') if !kwargs.empty?
           block_str = block ? " { }" : ""
 
-          lines << "#{var}#{receiver}#{method_name}(#{arguments.join(', ')})#{block_str}"
+          lines << "#{var_eq}#{receiver}#{method_name}(#{arguments.join(', ')})#{block_str}"
 
-          eval_one(symbolic_call)
+          var
         end
       end
     end
 
     private
 
+    def try_eval(symbolic_call)
+      SymbolicCaller.new(symbolic_call).eval
+    rescue RuntimeError, NotImplementedError
+      symbolic_call
+    end
+
+    def walk(&)
+      _walk(@symbolic_call, &)
+    end
+
     def _walk(symbolic_call, &block)
       return symbolic_call if BindCall::instance_of?(symbolic_call, BasicObject)
       return symbolic_call if !BindCall.respond_to?(symbolic_call, :deconstruct) && !BindCall.respond_to?(symbolic_call, :deconstruct_keys)
@@ -78,6 +118,8 @@ module RaaP
         args = _walk(args, &block) if !args.empty?
         kwargs = _walk(kwargs, &block) if !kwargs.empty?
         block.call [:call, receiver, method_name, args, kwargs, b]
+      in Var
+        symbolic_call.name
       in Array
         symbolic_call.map { |sc| _walk(sc, &block) }
       in Hash
@@ -89,12 +131,10 @@ module RaaP
 
     def eval_one(symbolic_call)
       symbolic_call => [:call, receiver_value, method_name, args, kwargs, block]
-
-      begin
+      if @allow_private
         receiver_value.__send__(method_name, *args, **kwargs, &block)
-      rescue => e
-        RaaP.logger.error("Cannot eval symbolic call #{symbolic_call} with #{e.class}")
-        raise
+      else
+        BindCall.public_send(receiver_value, method_name, *args, **kwargs, &block)
       end
     end
 
@@ -102,22 +142,28 @@ module RaaP
       printable(mod).gsub('::', '_').downcase
     end
 
-    def printable?(obj)
-      case obj
-      when Symbol, Integer, Float, Regexp, nil, true, false, String, Module
-        true
-      else
-        false
+    def printable(obj)
+      if obj in [:call, _, Symbol, Array, Hash, _]
+        return _walk(obj)
       end
-    end
 
-    def printable(obj)
       case obj
+      when Var
+        obj.name
       # Object from which it can get strings that can be eval with `#inspect`
       when Symbol, Integer, Float, Regexp, nil, true, false
         obj.inspect
       when String
         obj.inspect.gsub('"', "'") or raise
+      when Hash
+        hash_body = obj.map do |k, v|
+          ks = printable(k)
+          vs = printable(v)
+          ks.start_with?(':') ? "#{ks[1..-1]}: #{vs}" : "#{ks} => #{vs}"
+        end
+        "{#{hash_body.join(', ')}}"
+      when Array
+        "[#{obj.map { |o| printable(o) }.join(', ')}]"
       when Module
         BindCall.name(obj) or raise
       else

data/lib/raap/type.rb

@@ -23,12 +23,14 @@ module RaaP
 
     # Type.register "::Integer::positive" { sized { |size| size } }
     def self.register(type_name, &block)
-      GENERATORS[type_name] = block
+      raise ArgumentError, "block is required" unless block
+      GENERATORS[type_name] = __skip__ = block
     end
 
     # Special class case
     register("::Array") do
-      t = type.args[0] || 'untyped'
+      _type = __skip__ = type
+      t = _type.args[0] || 'untyped'
       array(Type.new(t, range: range))
     end
     register("::Binding") { sized { binding } }
@@ -40,8 +42,9 @@ module RaaP
     register("::Hash") do
       sized do |size|
         Array.new(integer.pick(size: size).abs).to_h do
-          k = type.args[0] || 'untyped'
-          v = type.args[1] || 'untyped'
+          _type = __skip__ = type
+          k = _type.args[0] || 'untyped'
+          v = _type.args[1] || 'untyped'
           [Type.new(k).pick(size: size), Type.new(v).pick(size: size)]
         end
       end
@@ -66,10 +69,20 @@ module RaaP
     def initialize(type, range: nil..nil)
       @type = parse(type)
       @range = range
+      @such_that = nil
+    end
+
+    def such_that(&block)
+      @such_that = block
+      self
     end
 
     def sized(&block)
-      Sized.new(&block)
+      Sized.new(&block).tap do |sized|
+        if s = @such_that
+          sized.such_that(&s)
+        end
+      end
     end
 
     def pick(size: 10, eval: true)
@@ -87,7 +100,17 @@ module RaaP
       when ::RBS::Types::Union
         type.types.sample&.then { |t| Type.new(t).pick(size:) }
       when ::RBS::Types::Intersection
-        Value::Intersection.new(type, size: size)
+        [:call, Value::Intersection, :new, [type], {size:}, nil]
+      when ::RBS::Types::Interface
+        [:call, Value::Interface, :new, [type], {size:}, nil]
+      when ::RBS::Types::Variable
+        [:call, Value::Variable, :new, [type], {}, nil]
+      when ::RBS::Types::Bases::Void
+        [:call, Value::Void, :new, [], {}, nil]
+      when ::RBS::Types::Bases::Top
+        [:call, Value::Top, :new, [], {}, nil]
+      when ::RBS::Types::Bases::Bottom
+        [:call, Value::Bottom, :new, [], {}, nil]
       when ::RBS::Types::Optional
         case Random.rand(2)
         in 0 then Type.new(type.type).pick(size:)
@@ -104,16 +127,12 @@ module RaaP
         raise "cannot resolve `instance` type"
       when ::RBS::Types::Bases::Self
         raise "cannot resolve `self` type"
-      when ::RBS::Types::Interface
-        Value::Interface.new(type, size: size)
-      when ::RBS::Types::Variable
-        Value::Variable.new(type)
       when ::RBS::Types::ClassSingleton
         Object.const_get(type.name.to_s)
       when ::RBS::Types::ClassInstance
         case gen = GENERATORS[type.name.absolute!.to_s]
-        when Proc then instance_exec(&gen).pick(size: size)
-        when nil then pick_from_initialize(type, size:)
+        in Proc then instance_exec(&gen).pick(size: size)
+        in nil then pick_from_initialize(type, size:)
         end
       when ::RBS::Types::Record
         type.fields.transform_values { |t| Type.new(t).pick(size:) }
@@ -123,21 +142,17 @@ module RaaP
         type.literal
       when ::RBS::Types::Bases::Bool
         bool.pick(size: size)
-      when ::RBS::Types::Bases::Void
-        Value::Void.new
       when ::RBS::Types::Bases::Any
         untyped.pick(size: size)
       when ::RBS::Types::Bases::Nil
         nil
-      when ::RBS::Types::Bases::Top
-        Value::Top.new
-      when ::RBS::Types::Bases::Bottom
-        Value::Bottom.new
       else
         raise "not implemented #{type.to_s}"
       end
     end
 
+    private
+
     def pick_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
@@ -162,12 +177,10 @@ module RaaP
           raise
         end
       else
-        Value::Module.new(type)
+        [:call, Value::Module, :new, [type], {}, nil]
       end
     end
 
-    private
-
     def parse(type)
       case type
       when String
@@ -279,24 +292,28 @@ module RaaP
 
     def encoding
       sized do
-        # @type block: RaaP::symbolic_call
-        e = Encoding.list.sample
+        e = Encoding.list.sample or raise
         [:call, Encoding, :find, [e.name], {} , nil]
       end
     end
 
     def bool
-      sized { [true, false].sample }
+      sized do
+        Random.rand(2) == 0
+      end
     end
 
     def untyped
-      case Random.rand(5)
+      case Random.rand(9)
       in 0 then integer
       in 1 then float
-      in 2 then string
-      in 3 then symbol
-      in 4 then bool
-      in 5 then encoding
+      in 2 then rational
+      in 3 then complex
+      in 4 then string
+      in 5 then symbol
+      in 6 then bool
+      in 7 then encoding
+      in 8 then sized { [:call, BasicObject, :new, [], {}, nil] }
       end
     end
 

data/lib/raap/value/module.rb

@@ -1,13 +1,14 @@
 module RaaP
   module Value
     # FIXME: consider self_types
-    class Module < BasicObject
+    # HINT: intersection?
+    class Module
       attr_reader :type
 
       def initialize(type)
         @type = type
         const = ::Object.const_get(type.name.absolute!.to_s)
-        BindCall.extend(self, const)
+        extend(const)
       end
 
       def inspect = "#<module #{@type}>"

data/lib/raap/version.rb

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

data/lib/raap.rb

@@ -16,14 +16,14 @@ module RaaP
   end
 
   self.logger = ::Logger.new($stdout)
-  self.logger.level = ::Logger::WARN
+  self.logger.level = ::Logger::INFO
 
   autoload :BindCall, "raap/bind_call"
   autoload :CLI, "raap/cli"
   autoload :FunctionType, "raap/function_type"
   autoload :MethodProperty, "raap/method_property"
   autoload :MethodType, "raap/method_type"
-  autoload :MethodValue, "raap/method_value"
+  autoload :Minitest, "raap/minitest"
   autoload :RBS, "raap/rbs"
   autoload :Result, "raap/result"
   autoload :Sized, "raap/sized"

data/sig/raap.rbs

@@ -19,15 +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) -> instance
+      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.[]: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer) -> 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.keyword_init?: () -> true
 
-      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
 
-      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
 
       attr_accessor dirs: ::Array[String]
 
@@ -42,6 +42,8 @@ module RaaP
       attr_accessor size_to: ::Integer
 
       attr_accessor size_by: ::Integer
+
+      attr_accessor allow_private: bool
     end
 
     @argv: Array[String]
@@ -81,12 +83,15 @@ module RaaP
       attr_accessor skip: Integer
       attr_accessor exception: Integer
     end
-    attr_reader receiver_type: Type
-    attr_reader method_name: Symbol
-    attr_reader method_type: MethodType
-    attr_reader size_step: _Each[Integer]
-    attr_reader timeout: (Integer | Float | nil)
-    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil)) -> void
+
+    @receiver_type: Type
+    @method_name: Symbol
+    @method_type: MethodType
+    @size_step: _Each[Integer]
+    @timeout: (Integer | Float | nil)
+    @allow_private: bool
+
+    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil), ?allow_private: bool) -> void
     def run: () { (Result::Success | Result::Failure | Result::Skip | Result::Exception) -> void } -> Stats
 
     private
@@ -103,33 +108,17 @@ module RaaP
     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, ?eval: bool) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
     def pick_block: (?size: Integer, ?eval: bool) -> ::Proc?
+    def check_return: (untyped) -> bool
   end
 
-  class MethodValue < Data
-    def self.new: (untyped receiver_value, [Array[untyped], Hash[Symbol, untyped], ::Proc?] arguments, Symbol method_name, Integer size) -> instance
-                | (receiver_value: untyped, arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?], method_name: Symbol, size: Integer) -> instance
-
-    def self.[]: (untyped receiver_value, [Array[untyped], Hash[Symbol, untyped], ::Proc?] arguments, Symbol method_name, Integer size) -> instance
-               | (receiver_value: untyped, arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?], method_name: Symbol, size: Integer) -> instance
-
-    def self.members: () -> [ :receiver_value, :arguments, :method_name, :size ]
-    def members: () -> [ :receiver_value, :arguments, :method_name, :size ]
-
-    attr_reader receiver_value: untyped
-    attr_reader arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?]
-    attr_reader method_name: Symbol
-    attr_reader size: Integer
-
-    def to_symbolic_call: () -> symbolic_call
-    def call_str: () -> String
-
-    private
-
-    def argument_str: () -> String
-    def block_str: () -> String?
+  module Minitest
   end
 
   module RBS
+    self.@builder: ::RBS::DefinitionBuilder
+    self.@env: ::RBS::Environment
+    self.@loader: ::RBS::EnvironmentLoader
+
     def self.builder: () -> ::RBS::DefinitionBuilder
     def self.env: () -> ::RBS::Environment
     def self.loader: () -> ::RBS::EnvironmentLoader
@@ -138,60 +127,67 @@ module RaaP
 
   module Result
     interface _MethodValueReturnValue
-      def method_value: () -> MethodValue
+      def symbolic_call: () -> symbolic_call
       def return_value: () -> untyped
     end
     module CalledStr : _MethodValueReturnValue
       def called_str: () -> String
     end
     class Success < Data
-      def self.new: (method_value: MethodValue, return_value: untyped) -> instance
-      attr_reader method_value: MethodValue
+      def self.new: (symbolic_call: symbolic_call, return_value: untyped) -> instance
+      attr_reader symbolic_call: symbolic_call
       attr_reader return_value: untyped
       include CalledStr
     end
     class Failure < Data
-      def self.new: (method_value: MethodValue, return_value: untyped, symbolic_call: symbolic_call) -> instance
-      attr_reader method_value: MethodValue
-      attr_reader return_value: untyped
+      def self.new: (symbolic_call: symbolic_call, return_value: untyped, ?exception: ::Exception?) -> instance
       attr_reader symbolic_call: symbolic_call
+      attr_reader return_value: untyped
+      attr_reader exception: ::Exception?
       include CalledStr
     end
     class Skip < Data
-      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
-      attr_reader method_value: MethodValue?
+      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
+      attr_reader symbolic_call: symbolic_call?
       attr_reader exception: ::Exception
     end
     class Exception < Data
-      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
-      attr_reader method_value: MethodValue?
+      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
+      attr_reader symbolic_call: symbolic_call?
       attr_reader exception: ::Exception
     end
   end
 
-  interface _Pick[T]
-    def pick: (size: Integer) -> T
-  end
-
-  class Sized
+  class Sized[T]
     @block: ::Proc
     @such_that: ::Proc?
 
     def initialize: () { (Integer) -> untyped } -> void
-    include _Pick[untyped]
+    def pick: (size: Integer) -> T
     def such_that: () { (untyped) -> boolish } -> self
     def such_that_loop: [R] () { (Integer) -> R } -> R
   end
 
   class SymbolicCaller
+    class Var
+      attr_reader name: String
+      def initialize: (String name) -> void
+      def +: (String) -> String
+      def to_s: () -> String
+    end
+
     attr_reader symbolic_call: untyped
-    def initialize: (untyped) -> void
+    attr_reader allow_private: bool
+
+    def initialize: (untyped, ?allow_private: bool) -> void
     def eval: () -> untyped
-    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
+    def call_str: () -> String
     def to_lines: () -> Array[String]
 
     private
 
+    def try_eval: (untyped) -> untyped
+    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
     def _walk: (untyped) ?{ (symbolic_call) -> untyped} -> untyped
     def eval_one: (symbolic_call) -> untyped
     def var_name: (Module) -> String
@@ -213,7 +209,7 @@ module RaaP
       def map_type: { (untyped) -> untyped } -> untyped
     end
 
-    def sub: (_MapType search, self_type: ::RBS::Types::ClassInstance?, instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> untyped
+    def sub: (_MapType search, self_type: ::RBS::Types::ClassInstance?, instance_type: ::RBS::Types::ClassInstance?, class_type: ::RBS::Types::ClassSingleton?) -> untyped
   end
 
   class Type
@@ -222,39 +218,45 @@ module RaaP
       def self.positive_float: () -> Float
     end
 
-    GENERATORS: Hash[String, ^() -> _Pick[untyped] | Proc]
+    @such_that: (^(untyped) -> ::boolish)?
+
+    GENERATORS: Hash[String, ^() -> Sized[untyped]]
     SIMPLE_SOURCE: Array[String]
     RECURSION: Hash[String, :found | :logged]
 
-    def self.register: (String) { () [self: instance] -> _Pick[untyped] } -> void
+    def self.register: (String) { () [self: instance] -> Sized[untyped] } -> void
     attr_reader type: ::RBS::Types::t
     attr_reader range: Range[untyped]
 
     def initialize: (String | ::RBS::Types::t, ?range: Range[untyped]) -> void
 
-    include _Pick[untyped]
-    def pick: (?size: Integer, ?eval: bool) -> untyped | ...
+    # Define rule for generating values
+    #     type.such_that { |i| i != 0 }.pick #=> ensure that the value is not 0
+    def such_that: () { (untyped) -> boolish } -> self
+
+    # Basic API for materializing values
+    def pick: (?size: Integer, ?eval: bool) -> untyped
     def to_symbolic_call: (?size: Integer) -> untyped
-    def pick_from_initialize: (::RBS::Types::ClassInstance, size: Integer) -> untyped
-    def sized: () { (Integer size) -> untyped } -> _Pick[untyped]
+    def sized: [T] () { (Integer size) -> T } -> Sized[T]
 
     private
 
+    def pick_from_initialize: (::RBS::Types::ClassInstance, size: Integer) -> (symbolic_call | Value::Module)
     def parse: (String | ::RBS::Types::t) -> ::RBS::Types::t?
     def try: (times: Integer, size: Integer) { (Integer size) -> untyped } -> untyped
 
-    def numeric: () -> _Pick[Numeric]
-    def integer: () -> _Pick[Integer]
-    def none_zero_integer: () -> _Pick[Integer]
-    def float: () -> _Pick[Float]
-    def rational: () -> _Pick[Rational]
-    def complex: () -> _Pick[Complex]
-    def string: () -> _Pick[String]
-    def symbol: () -> _Pick[Symbol]
-    def array: (Type) -> _Pick[Array[untyped]]
-    def encoding: () -> _Pick[Encoding]
-    def bool: () -> _Pick[bool]
-    def untyped: () -> _Pick[untyped]
+    def numeric: () -> Sized[Numeric]
+    def integer: () -> Sized[Integer]
+    def none_zero_integer: () -> Sized[Integer]
+    def float: () -> Sized[Float]
+    def rational: () -> Sized[symbolic_call]
+    def complex: () -> Sized[symbolic_call]
+    def string: () -> Sized[String]
+    def symbol: () -> Sized[Symbol]
+    def array: (Type) -> Sized[Array[untyped]]
+    def encoding: () -> Sized[symbolic_call]
+    def bool: () -> Sized[bool]
+    def untyped: () -> Sized[untyped]
     def temp_method_object: () -> ::Method
   end
 
@@ -284,7 +286,7 @@ module RaaP
       def class: () -> class
     end
 
-    class Module < BasicObject
+    class Module
       attr_reader type: ::RBS::Types::ClassInstance
 
       def initialize: (::RBS::Types::ClassInstance) -> void

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-20 00:00:00.000000000 Z
+date: 2024-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -59,7 +59,7 @@ files:
 - lib/raap/function_type.rb
 - lib/raap/method_property.rb
 - lib/raap/method_type.rb
-- lib/raap/method_value.rb
+- lib/raap/minitest.rb
 - lib/raap/rbs.rb
 - lib/raap/result.rb
 - lib/raap/sized.rb

data/lib/raap/method_value.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RaaP
-  class MethodValue < Data.define(
-    :receiver_value,
-    :arguments,
-    :method_name,
-    :size
-  )
-    def to_symbolic_call
-      args, kwargs, block = arguments
-      [:call, receiver_value, method_name, args, kwargs, block]
-    end
-
-    def call_str
-      r = SymbolicCaller.new(receiver_value).eval
-      "#{BindCall.inspect(r)}.#{method_name}(#{argument_str})#{block_str}"
-    end
-
-    private
-
-    def argument_str
-      args, kwargs, _ = SymbolicCaller.new(arguments).eval
-
-      r = []
-      r << args.map(&:inspect).join(', ') if !args.empty?
-      r << kwargs.map { |k ,v| "#{k}: #{BindCall.inspect(v)}" }.join(', ') if !kwargs.empty?
-      r.join(', ')
-    end
-
-    def block_str
-      _, _, block = SymbolicCaller.new(arguments).eval
-      if block
-        "{ }"
-      end
-    end
-  end
-end