raap 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e9d7ac0f6d02b3bc1dce9ad5d49d47d0b73825cfdb60a9e2a9f60a7ab0538a4
-  data.tar.gz: 5e4204d5ce36b5b271ff715ad460533e27edd625c7e2b9a075d8d4e6db4ff6e0
+  metadata.gz: 272cb44584fb297591d356de0c90ecfbcf782951ed4a02432eb4cd87a6849f0f
+  data.tar.gz: d0776eeeb3f840a1730f16a9df385414e3697631191961b986085773cad49e04
 SHA512:
-  metadata.gz: cd12a1a50335e228a4700dd048d66f835a0963b4dd7373a890c02c9975d1587c9929604d18b6ce51a1696ce67c3b15c9d9f2d06f76aa22e9a9f6f467c8ee3fbb
-  data.tar.gz: f1cb139f0169359bda70f3cbaa03db45f110941d7559531d4f5c02cc8c04ec477f22effb293a6e64db90218101069a9084255d4b75cf64aa0403af20cc4f910b
+  metadata.gz: '09ace505a4973cac5f075a133fc6e13c8fa34bde72adf522cc095ad3accfccec574b3209aaf4bca8deceb398b5b36f0893672722504895d51413c65877efc167'
+  data.tar.gz: 1fe3eb4b5695bd69b2a30fdd2035a81aa3be1a289dee120f4664f95bb1d6d9a5ab8849f11acb957e8ac97e8dfb174f49536542fc96f29ecfade076e15b76619e

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) }
 
-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.
+  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`
+
+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
 

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

@@ -103,7 +103,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 +125,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 +158,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 +167,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 +180,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 +194,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 +211,23 @@ 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,
       ).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}`"
           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 +236,11 @@ module RaaP
           throw :break
         in Result::Skip => s
           print 'S'
+          RaaP::logger.debug("Skip: [#{s.exception.class}] #{s.exception.message}")
         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.info("Exception: [#{e.exception.class}] #{e.exception.message}")
+          RaaP.logger.debug(e.exception.backtrace.join("\n"))
         end
       end
       puts

data/lib/raap/method_property.rb

@@ -24,9 +24,6 @@ module RaaP
 
     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
@@ -48,24 +45,31 @@ module RaaP
       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
+      begin
+        # ensure method_value
+        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
+          end
+        else
           return_value = SymbolicCaller.new(symbolic_call).eval
-        rescue => e
-          check = true
-          return_value = Value::Bottom.new
+          check = check_return(receiver_value:, return_value:, 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
+        if check
+          stats.success += 1
+          Result::Success.new(method_value:, return_value:)
+        else
+          Result::Failure.new(method_value:, return_value:, symbolic_call:)
+        end
+      rescue TypeError => exception
         Result::Failure.new(method_value:, return_value:, symbolic_call:)
       end
+
+    # not ensure method_value
     rescue NoMethodError => exception
       stats.skip += 1
       Result::Skip.new(method_value:, exception:)
@@ -80,8 +84,6 @@ module RaaP
       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:)
     rescue => exception
       stats.exception += 1
       Result::Exception.new(method_value:, exception:)
@@ -104,7 +106,7 @@ module RaaP
         instance_class: instance_class,
         class_class: Module,
         builder: RBS.builder,
-        sample_size: 1,
+        sample_size: 100,
         unchecked_classes: []
       )
       begin

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/symbolic_caller.rb

@@ -16,6 +16,21 @@ 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
 
     def initialize(symbolic_call)
@@ -39,18 +54,27 @@ 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 = ""
+            var_eq = ""
             receiver = if printable?(receiver_value)
-              printable(receiver_value) + '.'
+              var = Var.new(printable(receiver_value))
+              var + '.'
             else
-              var_name(receiver_value.class) + '.'
+              var = Var.new(var_name(receiver_value.class))
+              var + '.'
             end
           end
 
@@ -59,9 +83,9 @@ 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
@@ -78,6 +102,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,13 +115,7 @@ module RaaP
 
     def eval_one(symbolic_call)
       symbolic_call => [:call, receiver_value, method_name, args, kwargs, block]
-
-      begin
-        receiver_value.__send__(method_name, *args, **kwargs, &block)
-      rescue => e
-        RaaP.logger.error("Cannot eval symbolic call #{symbolic_call} with #{e.class}")
-        raise
-      end
+      BindCall.public_send(receiver_value, method_name, *args, **kwargs, &block)
     end
 
     def var_name(mod)
@@ -104,7 +124,7 @@ module RaaP
 
     def printable?(obj)
       case obj
-      when Symbol, Integer, Float, Regexp, nil, true, false, String, Module
+      when Symbol, Integer, Float, Regexp, nil, true, false, String, Module, Var
         true
       else
         false
@@ -113,6 +133,8 @@ module RaaP
 
     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

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)
@@ -112,8 +125,8 @@ module RaaP
         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:) }
@@ -138,6 +151,8 @@ module RaaP
       end
     end
 
+    private
+
     def pick_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
@@ -166,8 +181,6 @@ module RaaP
       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 { BasicObject.new }
       end
     end
 

data/lib/raap/version.rb

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

data/lib/raap.rb

@@ -16,7 +16,7 @@ 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"
@@ -24,6 +24,7 @@ module RaaP
   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

@@ -103,6 +103,7 @@ 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
@@ -129,7 +130,14 @@ module RaaP
     def block_str: () -> String?
   end
 
+  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
@@ -169,21 +177,24 @@ module RaaP
     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
     def eval: () -> untyped
@@ -213,7 +224,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 +233,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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-20 00:00:00.000000000 Z
+date: 2024-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -60,6 +60,7 @@ files:
 - 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