raap 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 312e27904176673d6962904901cb3e8d31c6b613b8efdf669c877d4670cf9d15
-  data.tar.gz: fe940b9d2928a54bfbba8a4842c097cb2a8efe6cf0b873baa383f757de37d017
+  metadata.gz: 94f0ec4ff924c5089f8e307002dd5f3cd778f04e686acd8b46466139c3c1aebd
+  data.tar.gz: e9a06fb3c71cfc6cd605031fe8cb899a123dc82a94ef00586d39e8329c45beac
 SHA512:
-  metadata.gz: 55070cb0335ae161e3a1f6e62d9faa9d205e0b1c92186d2e81eaea2547d476d092fa90a9c6607d2d4ad11cf1f0a0bab723539e90cc4932d49bc297e069e07632
-  data.tar.gz: 771e2f640454bfcd8774ccc0d1ac3079df7e6f1edb7d209327881fea2febb6bbfe04af937481e3e6d81bf9b05046860fc7d861af38b523872d1af8d62a0717da
+  metadata.gz: ed0d647fefa8591c0a03981232c84d64bf7c70bcf9207d2dd6471a9f3369747b5dd3adcc3cd60a8e1d65f0e1543ed7a5f5108eef6523c7d306cfc399d0bc63e4
+  data.tar.gz: 537c5dfbb65bb12064e46c47fb75a60321ee0f16296f1272ef27d68927f4f9f3d5875ea6f3ac2225c76a2d274fbe393bff20f573b8d138b52a6ced8027528e1f

data/.rubocop.yml

@@ -14,6 +14,8 @@ Style:
 Style/HashSyntax:
   EnforcedShorthandSyntax: always
   Enabled: true
+Style/FrozenStringLiteralComment:
+  Enabled: true
 
 Metrics:
   Enabled: false

data/README.md

@@ -1,6 +1,6 @@
 # RaaP
 
-![Jacket](https://raw.githubusercontent.com/ksss/raap/main/public/DALL%C2%B7E%202024-03-23%2000.02.29%20-%20Imagine%20a%20scene%20where%20the%20abstract%20concepts%20of%20Ruby%20programming%20and%20property-based%20testing%20blend%20harmoniously.%20Picture%20a%20large%2C%20glowing%20ruby%20crystal%2C%20.webp)
+<img src="https://raw.githubusercontent.com/ksss/raap/main/public/jacket.webp" width=400/>
 
 ## RBS as a Property
 
@@ -70,6 +70,15 @@ $ raap 'MyClass'                  # Run only RBS of MyClass
 $ raap 'MyClass::*'               # Run each class under MyClass
 $ raap 'MyClass.singleton_method' # Run only MyClass.singleton_method
 $ raap 'MyClass#instance_method'  # Run only MyClass#instance_method
+$ raap 'MyClass' '!MyClass#skip'  # Run method MyClass without #skip
+```
+
+```
+$ cat test/raap.txt
+MyClass
+!MyClass#skip
+
+$ raap $(cat test/raap.txt)   # You can manage the methods to be tested in a file
 ```
 
 ## Size
@@ -103,11 +112,15 @@ You can specify to load specify PATH as RBS.
 
 ### `--library lib`
 
-You can specify to load RBS library
+You can specify to load RBS library.
 
 ### `--require lib`
 
-You can specify require Ruby library
+You can specify require Ruby library.
+
+### `--log-level level`
+
+You can specify log level (debug, info, warn or error).
 
 ### `--timeout sec`
 
@@ -125,6 +138,11 @@ You can specify size of end.
 
 You can specify size of step like `Integer#step: (to: Integer, by: Integer)`.
 
+### `--allow-private`
+
+By default, raap only validates public methods.
+However, by setting this option, it is possible to intentionally validate private methods in the RBS.
+
 ## First support is CLI
 
 In RaaP, usage through the CLI is the primary support focus, and efforts are made to maintain compatibility. The use of the library's code (such as `RaaP::Type`) does not guarantee compatibility.

data/exe/raap

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'raap'
 

data/lib/raap/bind_call.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module RaaP
   module BindCall
     class << self
-      def define_singleton_method(...) = ::Object.instance_method(:define_singleton_method).bind_call(...)
+      def define_method(...) = ::Module.instance_method(:define_method).bind_call(...)
       def respond_to?(...) = ::Kernel.instance_method(:respond_to?).bind_call(...)
       def instance_of?(...) = ::Kernel.instance_method(:instance_of?).bind_call(...)
       def is_a?(...) = ::Kernel.instance_method(:is_a?).bind_call(...)

data/lib/raap/cli.rb

@@ -12,7 +12,6 @@ module RaaP
       :size_to,
       :size_by,
       :allow_private,
-      :skips,
       keyword_init: true
     )
 
@@ -45,7 +44,6 @@ module RaaP
         size_from: 0,
         size_to: 99,
         size_by: 1,
-        skips: [],
         allow_private: false,
       )
       @argv = argv
@@ -64,7 +62,7 @@ module RaaP
         o.on('--require lib', 'require ruby library') do |lib|
           @option.requires << lib
         end
-        o.on('--log-level level', "default: warn") do |arg|
+        o.on('--log-level level', "default: info") do |arg|
           RaaP.logger.level = arg
         end
         o.on('--timeout sec', Float, "default: #{@option.timeout}") do |arg|
@@ -82,9 +80,6 @@ module RaaP
         o.on('--allow-private', "default: #{@option.allow_private}") do
           @option.allow_private = true
         end
-        o.on('--skip tag', "skip case (e.g. `Foo#meth`)") do |tag|
-          @option.skips << tag
-        end
       end.parse!(@argv)
 
       @option.dirs.each do |dir|
@@ -96,10 +91,6 @@ module RaaP
       @option.requires.each do |lib|
         require lib
       end
-      @option.skips.each do |skip|
-        @skip << skip
-      end
-      @skip.freeze
 
       self
     end
@@ -111,7 +102,20 @@ module RaaP
         exit 1
       end
 
-      @argv.map do |tag|
+      # Search skip tag
+      @argv.each do |tag|
+        if tag.start_with?('!') && (tag.include?('#') || tag.include?('.'))
+          t = tag[1..] or raise
+          t = "::#{t}" unless t.start_with?('::')
+          t or raise
+          @skip << t
+        end
+      end
+      @skip.freeze
+
+      @argv.each do |tag|
+        next if tag.start_with?('!')
+
         case
         when tag.include?('#')
           run_by(kind: :instance, tag:)
@@ -204,7 +208,11 @@ module RaaP
     def run_by_type_name_with_search(tag:)
       first, _last = tag.split('::')
       RBS.env.class_decls.each do |name, _entry|
-        if ['', '::'].any? { |pre| name.to_s.match?(/\A#{pre}#{first}\b/) }
+        if ['', '::'].any? { |pre| name.to_s.start_with?("#{pre}#{first}") }
+          if @skip.include?(name.to_s)
+            RaaP.logger.info("Skip #{name}")
+            next
+          end
           run_by_type_name(tag: name.to_s)
         end
       end
@@ -220,8 +228,11 @@ 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 if @skip.include?("#{type_name.absolute!}.#{method_name}")
+      definition.methods.each do |method_name, method|
+        if @skip.include?("#{type_name.absolute!}.#{method_name}")
+          RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")
+          next
+        end
         next unless method.accessibility == :public
         next if method.defined_in != type_name
 
@@ -236,8 +247,11 @@ 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 if @skip.include?("#{type_name.absolute!}##{method_name}")
+      definition.methods.each do |method_name, method|
+        if @skip.include?("#{type_name.absolute!}##{method_name}")
+          RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")
+          next
+        end
         next unless method.accessibility == :public
         next if method.defined_in != type_name
 
@@ -258,9 +272,11 @@ module RaaP
       else
         prefix = ''
       end
-      type_params_decl.each_with_index do |_, i|
+
+      # type_args delegate to self_type
+      type_params_decl.each_with_index do |param, i|
         if rtype.instance_of?(::RBS::Types::ClassInstance)
-          rtype.args[i] = type_args[i] || ::RBS::Types::Bases::Any.new(location: nil)
+          rtype.args[i] = type_args[i] || param.upper_bound || ::RBS::Types::Bases::Any.new(location: nil)
         end
       end
       RaaP.logger.info("## def #{prefix}#{method_name}: #{method_type}")
@@ -279,7 +295,7 @@ module RaaP
         ),
         size_step: @option.size_from.step(to: @option.size_to, by: @option.size_by),
         timeout: @option.timeout,
-        allow_private: true,
+        allow_private: @option.allow_private,
       )
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       stats = prop.run do |called|
@@ -290,7 +306,7 @@ module RaaP
         in Result::Failure => f
           puts 'F'
           if (e = f.exception)
-            RaaP.logger.debug { "Failure: [#{e.class}] #{e.message}" }
+            RaaP.logger.info { "Failure: [#{e.class}] #{e.message}" }
             RaaP.logger.debug { e.backtrace.join("\n") }
           end
           RaaP.logger.debug { PP.pp(f.symbolic_call, ''.dup) }

data/lib/raap/method_property.rb

@@ -50,7 +50,7 @@ module RaaP
     private
 
     def call(size:, stats:)
-      if @method_type.rbs.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) }
+      if @method_type.rbs.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

data/lib/raap/minitest.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'minitest'
 
 module RaaP

data/lib/raap/type.rb

@@ -39,6 +39,30 @@ module RaaP
       end
     end
 
+    def self.call_new_from(base, type, size:)
+      type_name = type.name.absolute!
+      definition = RBS.builder.build_singleton(type_name)
+      snew = definition.methods[:new]
+      if snew
+        # class
+        rbs_method_type = snew.method_types.sample or raise
+        type_params = definition.type_params_decl.concat(rbs_method_type.type_params.drop(definition.type_params_decl.length))
+        ts = TypeSubstitution.new(type_params, type.args)
+        maped_rbs_method_type = ts.method_type_sub(rbs_method_type)
+        method_type = MethodType.new(maped_rbs_method_type)
+
+        begin
+          args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
+          [:call, base, :new, args, kwargs, block]
+        rescue
+          $stderr.puts "Fail with `#{rbs_method_type}`"
+          raise
+        end
+      else
+        [:call, Value::Module, :new, [type.to_s], { size: }, nil]
+      end
+    end
+
     # Special class case
     register("::Array") do
       instance = __skip__ = type
@@ -141,9 +165,11 @@ module RaaP
         in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size:)
         end
       when ::RBS::Types::Bases::Class
-        raise "cannot resolve `class` type"
+        RaaP.logger.warn("Unresolved `class` type, use Object instead.")
+        Object
       when ::RBS::Types::Bases::Instance
-        raise "cannot resolve `instance` type"
+        RaaP.logger.warn("Unresolved `instance` type, use Object.new instead.")
+        Object.new
       when ::RBS::Types::Bases::Self
         raise "cannot resolve `self` type"
       when ::RBS::Types::ClassSingleton
@@ -175,28 +201,7 @@ module RaaP
     def to_symbolic_call_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
-      definition = RBS.builder.build_singleton(type_name)
-      snew = definition.methods[:new]
-      if snew
-        # class
-        rbs_method_type = snew.method_types.sample or raise
-        type_params = definition.type_params_decl.concat(rbs_method_type.type_params.drop(definition.type_params_decl.length))
-        ts = TypeSubstitution.new(type_params, type.args)
-        maped_rbs_method_type = ts.method_type_sub(rbs_method_type)
-        method_type = MethodType.new(maped_rbs_method_type)
-
-        begin
-          try(times: 5, size:) do |size|
-            args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
-            [:call, const, :new, args, kwargs, block]
-          end
-        rescue
-          $stderr.puts "Fail with `#{rbs_method_type}`"
-          raise
-        end
-      else
-        [:call, Value::Module, :new, [type.to_s], { size: }, nil]
-      end
+      Type.call_new_from(const, type, size:)
     end
 
     def parse(type)
@@ -210,31 +215,6 @@ module RaaP
       end
     end
 
-    def try(times:, size:)
-      # @type var error: Exception?
-      ret = error = nil
-      times.times do
-        ret = yield size
-        if ret
-          error = nil
-          break
-        end
-      rescue => e
-        size += 1
-        error = e
-        next
-      end
-
-      if error
-        $stderr.puts
-        $stderr.puts "=== Catch error when generating type `#{type}`. Please check your RBS or RaaP bug. ==="
-        $stderr.puts "(#{error.class}) #{error.message}"
-        raise error
-      end
-
-      ret
-    end
-
     def integer
       sized { |size| float.pick(size:).round }
     end

data/lib/raap/type_substitution.rb

@@ -21,6 +21,9 @@ module RaaP
     end
 
     def method_type_sub(method_type, self_type: nil, instance_type: nil, class_type: nil)
+      self_type = self_type.is_a?(::String) ? RBS.parse_type(self_type) : self_type
+      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
       ::RBS::MethodType.new(
         type_params: [],

data/lib/raap/value/bottom.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     class Bottom < BasicObject

data/lib/raap/value/interface.rb

@@ -3,43 +3,69 @@
 module RaaP
   module Value
     class Interface < BasicObject
-      def initialize(type, size: 3, self_type: nil, instance_type: nil, class_type: nil)
-        @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}"
-        end
-        @size = size
+      class << self
+        def define_method_from_interface(base_class, 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}"
+          end
+          self_type = type
 
-        @definition = RBS.builder.build_interface(@type.name.absolute!)
-        @definition.methods.each do |name, method|
-          method_type = method.method_types.sample or Kernel.raise
-          type_params = @definition.type_params_decl.concat(method_type.type_params.drop(@definition.type_params_decl.length))
-          ts = TypeSubstitution.new(type_params, @type.args)
-
-          subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
-
-          BindCall.define_singleton_method(self, name) do |*_, &b|
-            # @type var b: Proc?
-            @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(size:)
-            if subed_method_type.block
-              @fixed_block_arguments ||= size.times.map do
-                fun_type = FunctionType.new(subed_method_type.block.type)
-                fun_type.pick_arguments(size:)
-              end
-            else
-              @fixed_block_arguments = []
-            end
-            if b
-              unless subed_method_type.block
-                Kernel.raise "block of `#{@type.name}##{name}` was called. But block signature not defined."
-              end
-              @fixed_block_arguments.each do |a, kw|
-                b.call(*a, **kw)
+          # Referring to Steep
+          instance_type = ::RBS::Types::ClassInstance.new(name: TypeName("::Object"), args: [], location: nil)
+          class_type = ::RBS::Types::ClassSingleton.new(name: TypeName("::Object"), location: nil)
+
+          definition = RBS.builder.build_interface(type.name.absolute!)
+          definition.methods.each do |name, method|
+            method_type = method.method_types.sample or ::Kernel.raise
+            type_params = definition.type_params_decl.concat(method_type.type_params.drop(definition.type_params_decl.length))
+            ts = TypeSubstitution.new(type_params, type.args)
+            subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
+
+            BindCall.define_method(base_class, name) do |*_, &b|
+              @fixed_return_value ||= {}
+              @fixed_return_value[name] ||= if self_type == subed_method_type.type.return_type
+                                              self
+                                            else
+                                              Type.new(subed_method_type.type.return_type).pick(size:)
+                                            end
+              # @type var b: Proc?
+              if b
+                @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:)
+                                                   end
+                                                 else
+                                                   []
+                                                 end
+                @fixed_block_arguments[name].each do |a, kw|
+                  b.call(*a, **kw)
+                end
               end
+              @fixed_return_value[name]
             end
-            @fixed_return_value
           end
         end
+
+        def new(type, size: 3)
+          temp_class = ::Class.new(Interface) do |c|
+            define_method_from_interface(c, type, size:)
+          end
+          instance = temp_class.allocate
+          instance.__send__(:initialize, type, size:)
+          instance
+        end
+      end
+
+      def initialize(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}"
+        end
+        @definition = RBS.builder.build_interface(@type.name.absolute!)
+        @size = size
       end
 
       def respond_to?(name, _include_all = false)
@@ -51,7 +77,7 @@ module RaaP
       end
 
       def inspect
-        "#<interface @type=#{@type} @methods=#{@definition.methods.keys} @size=#{@size}>"
+        "#<interface @type=`#{@type}` @methods=#{@definition.methods.keys} @size=#{@size}>"
       end
     end
   end

data/lib/raap/value/intersection.rb

@@ -2,45 +2,38 @@
 
 module RaaP
   module Value
-    class Intersection < BasicObject
-      def initialize(type, size: 3)
-        @type = type.is_a?(::String) ? RBS.parse_type(type) : type
-        unless @type.instance_of?(::RBS::Types::Intersection)
-          ::Kernel.raise ::TypeError, "not an intersection type: #{@type}"
+    module Intersection
+      # Build an object to realize an intersection.
+      def self.new(type, size: 3)
+        type = type.is_a?(::String) ? RBS.parse_type(type) : type
+        unless type.instance_of?(::RBS::Types::Intersection)
+          ::Kernel.raise ::TypeError, "not an intersection type: #{type}"
+        end
+        instances = type.types.filter_map do |t|
+          t.instance_of?(::RBS::Types::ClassInstance) && Object.const_get(t.name.absolute!.to_s)
+        end
+        instances.uniq!
+        unless instances.count { |c| c.is_a?(::Class) } <= 1
+          raise ArgumentError, "intersection type must have at least one class instance type in `#{instances}`"
         end
-        @children = @type.types.map { |t| Type.new(t).pick(size:) }
-        @size = size
-      end
 
-      def inspect
-        "#<intersection @type.to_s=#{@type.to_s.inspect} @size=#{@size.inspect}>"
-      end
+        base = instances.find { |c| c.is_a?(::Class) } || BasicObject
 
-      def class
-        Intersection
-      end
+        c = Class.new(base) do
+          instances.select { |i| !i.is_a?(::Class) }.each do |m|
+            include(m)
+          end
 
-      def method_missing(name, *args, **kwargs, &block)
-        if respond_to?(name)
-          @children.each do |child|
-            if BindCall.respond_to?(child, name)
-              return child.__send__(name, *args, **kwargs, &block)
-            end
+          interfaces = type.types.select do |t|
+            t.instance_of?(::RBS::Types::Interface)
           end
-          ::Kernel.raise
-        else
-          super
-        end
-      end
 
-      def respond_to?(name, include_all = false)
-        @children.any? do |child|
-          if BindCall.instance_of?(child, ::BasicObject)
-            BindCall.respond_to?(child, name, include_all)
-          else
-            child.respond_to?(name, include_all)
+          interfaces.each do |interface|
+            Interface.define_method_from_interface(self, interface, size:)
           end
         end
+        type = ::RBS::Types::ClassInstance.new(name: TypeName(base.name), args: [], location: nil)
+        SymbolicCaller.new(Type.call_new_from(c, type, size:)).eval
       end
     end
   end

data/lib/raap/value/module.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     # FIXME: consider self_types
@@ -30,12 +32,14 @@ module RaaP
                            "#{a_instance.name}[#{args.map(&:to_s).join(', ')}]"
                          end
                        end.then do |ts|
-                         ts << 'Object' if !ts.include?('::BasicObject')
-                         Type.new(ts.join(' & ')).pick(size:)
+                         if !ts.include?('::BasicObject') || ts.any? { |t| t.split('::').last&.start_with?('_') }
+                           ts.unshift('Object')
+                         end
+                         Type.new(ts.uniq.join(' & ')).pick(size:)
                        end
                      end
         const = ::Object.const_get(@type.name.absolute!.to_s)
-        BindCall.extend(@self_type, const)
+        BindCall.extend(self, const)
       end
 
       def method_missing(name, *args, **kwargs, &block)

data/lib/raap/value/top.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     class Top < BasicObject

data/lib/raap/value/variable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     class Variable < BasicObject

data/lib/raap/value/void.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     class Void < BasicObject

data/lib/raap/version.rb

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

data/sig/raap.rbs

@@ -6,7 +6,7 @@ module RaaP
   def self.logger=: (::Logger) -> void
 
   module BindCall
-    def self.define_singleton_method: (untyped, Symbol) { (*untyped, **untyped) -> untyped } -> void
+    def self.define_method: (untyped, Symbol) { (*untyped, **untyped) -> untyped } -> void
     def self.respond_to?: (untyped, untyped, ?boolish) -> bool
     def self.instance_of?: (untyped, Module) -> bool
     def self.is_a?: (untyped, Module) -> bool
@@ -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, ?allow_private: bool, ?skips: ::Array[::String]) -> 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, ?allow_private: bool, ?skips: ::Array[::String]) -> 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, :allow_private, :skips]
+      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, :allow_private, :skips]
+      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
 
       attr_accessor dirs: ::Array[String]
 
@@ -44,8 +44,6 @@ module RaaP
       attr_accessor size_by: ::Integer
 
       attr_accessor allow_private: bool
-
-      attr_accessor skips: ::Array[String]
     end
 
     type property_result = [Integer, Symbol, ::RBS::MethodType, StringIO?]
@@ -53,7 +51,9 @@ module RaaP
     DEFAULT_SKIP: ::Set[String]
 
     @argv: Array[String]
+    @option: Option
     @results:  Array[{ method: ::RBS::Definition::Method, properties: Array[property_result] }]
+    @skip: ::Set[::String]
 
     def self.option: () -> Option
     def self.option=: (Option) -> void
@@ -220,7 +220,7 @@ module RaaP
 
     def initialize: (::Array[::RBS::AST::TypeParam], ::Array[::RBS::Types::t]) -> void
     def build: () -> ::RBS::Substitution
-    def method_type_sub: (::RBS::MethodType, ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> ::RBS::MethodType
+    def method_type_sub: (::RBS::MethodType, ?self_type: ::RBS::Types::t?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> ::RBS::MethodType
 
     private
 
@@ -228,7 +228,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::t?, instance_type: ::RBS::Types::t?, class_type: ::RBS::Types::t?) -> untyped
   end
 
   class Type
@@ -245,6 +245,7 @@ module RaaP
     def self.register: (String) { () [self: instance] -> Sized[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
 
     attr_reader type: ::RBS::Types::t
     attr_reader range: Range[untyped]
@@ -292,9 +293,8 @@ module RaaP
       @type: ::RBS::Types::Interface
       @size: Integer
       @definition: ::RBS::Definition
-      @fixed_return_value: untyped
-      @fixed_block_arguments: Array[untyped]
 
+      def self.define_method_from_interface: (Class 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-14 00:00:00.000000000 Z
+date: 2024-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs