raap 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f734d53db009621045979dfc7d705b14c2f378625ff36067784995e8889134
-  data.tar.gz: 472adf32ff8ea739d83a5b41c6a62e80149b29e34d44536df844010eb2e8cb90
+  metadata.gz: f119356b79f6beb968f26d019dda506e8eada4a48e178bd029e7e97d187f2d2c
+  data.tar.gz: f72f9d682ff47f11d51ebcf547a7f991c75b9be731eabc018fbb5b5a727dc358
 SHA512:
-  metadata.gz: cc3782c7a65e098eef727163ccc069ca27b339eeaadc7be44abd2eac94c78fa74443c413364e579998dd49aa11c5be38bd27f6504f92759580ec893dd54a3e97
-  data.tar.gz: 68e133fa67a03d4c84ab264c1e0fd1c40204da8995a552e99912eb61c1cddb14d9c81bac26c4aa04615d9833dfa74ad64bd212071dd3195dacad6ae85bd23b54
+  metadata.gz: 7d3fbbfd916eb8526d9021e94408f4af402d80455c89b822c74557a76a31b8fc93a0d7acd8e47efdca32a8b1a19fb37a2b8f997e3c7ad6083e2f61d72052973a
+  data.tar.gz: cfbeb8a13d53e16a6e51701c30354ea1537c8b6b7a7ef46665b7e0efe9db43a4ce769370f38f558e4a384c80a039960faa65acbc8648c8f36e3725a53c2c1075

data/README.md

@@ -57,6 +57,10 @@ Then, you can start loop again.
 
 Finally, you get the perfect RBS!
 
+## Slide
+
+https://speakerdeck.com/ksss/raap
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/lib/raap/cli.rb

@@ -38,9 +38,6 @@ module RaaP
     def initialize(argv)
       # defaults
       @option = Option.new(
-        dirs: [],
-        requires: [],
-        libraries: [],
         timeout: 3,
         size_from: 0,
         size_to: 99,
@@ -56,13 +53,13 @@ module RaaP
     def load
       OptionParser.new do |o|
         o.on('-I', '--include PATH') do |path|
-          @option.dirs << path
+          RaaP::RBS.loader.add(path: Pathname(path))
         end
         o.on('--library lib', 'load rbs library') do |lib|
-          @option.libraries << lib
+          RaaP::RBS.loader.add(library: lib, version: nil)
         end
         o.on('--require lib', 'require ruby library') do |lib|
-          @option.requires << lib
+          require lib
         end
         o.on('--log-level level', "default: info") do |arg|
           RaaP.logger.level = arg
@@ -90,16 +87,6 @@ module RaaP
         end
       end.parse!(@argv)
 
-      @option.dirs.each do |dir|
-        RaaP::RBS.loader.add(path: Pathname(dir))
-      end
-      @option.libraries.each do |lib|
-        RaaP::RBS.loader.add(library: lib, version: nil)
-      end
-      @option.requires.each do |lib|
-        require lib
-      end
-
       self
     end
 

data/lib/raap/coverage.rb

@@ -25,7 +25,7 @@ module RaaP
               RaaP.logger.warn("No location information for `#{phantom_member}`")
               return
             end
-            write_type(io, "return", phantom_member.type, :abs)
+            write_type(io, "return", phantom_member.type)
             io.write(slice(@cur, @cur...phantom_member.location.end_pos))
           else
             RaaP.logger.error("#{phantom_member.class} is not supported")
@@ -37,22 +37,22 @@ module RaaP
           phantom_method_type.type.yield_self do |fun|
             case fun
             when ::RBS::Types::Function
-              fun.required_positionals.each_with_index { |param, i| write_param(io, "req_#{i}", param, :abs) }
-              fun.optional_positionals.each_with_index { |param, i| write_param(io, "opt_#{i}", param, :opt) }
-              fun.rest_positionals&.yield_self         { |param| write_param(io, "rest", param, :opt) }
-              fun.trailing_positionals.each_with_index { |param, i| write_param(io, "trail_#{i}", param, :abs) }
-              fun.required_keywords.each               { |key, param| write_param(io, "keyreq_#{key}", param, :abs) }
-              fun.optional_keywords.each               { |key, param| write_param(io, "key_#{key}", param, :opt) }
-              fun.rest_keywords&.yield_self            { |param| write_param(io, "keyrest", param, :opt) }
+              fun.required_positionals.each_with_index { |param, i| write_param(io, "req_#{i}", param) }
+              fun.optional_positionals.each_with_index { |param, i| write_param(io, "opt_#{i}", param) }
+              fun.rest_positionals&.yield_self         { |param| write_param(io, "rest", param) }
+              fun.trailing_positionals.each_with_index { |param, i| write_param(io, "trail_#{i}", param) }
+              fun.required_keywords.each               { |key, param| write_param(io, "keyreq_#{key}", param) }
+              fun.optional_keywords.each               { |key, param| write_param(io, "key_#{key}", param) }
+              fun.rest_keywords&.yield_self            { |param| write_param(io, "keyrest", param) }
               # when ::RBS::Types::UntypedFunction
             end
           end
 
           phantom_method_type.block&.yield_self do |b|
-            b.type.each_param.with_index { |param, i| write_param(io, "block_param_#{i}", param, :opt) }
-            write_type(io, "block_return", b.type.return_type, :abs)
+            b.type.each_param.with_index { |param, i| write_param(io, "block_param_#{i}", param) }
+            write_type(io, "block_return", b.type.return_type)
           end
-          write_type(io, "return", phantom_method_type.type.return_type, :abs)
+          write_type(io, "return", phantom_method_type.type.return_type)
           raise unless phantom_method_type.location
 
           io.write(slice(@cur, @cur...phantom_method_type.location.end_pos))
@@ -70,11 +70,11 @@ module RaaP
         ml.source[start, range.end - range.begin] or raise
       end
 
-      def write_param(io, position, param, accuracy)
-        write_type(io, position, param.type, accuracy)
+      def write_param(io, position, param)
+        write_type(io, position, param.type)
       end
 
-      def write_type(io, position, type, accuracy)
+      def write_type(io, position, type)
         unless type.location
           RaaP.logger.warn("No location information for `#{type}`")
           return
@@ -88,12 +88,12 @@ module RaaP
             t.location or raise
             io.write(slice(@cur, @cur...t.location.start_pos)) # ( or [
             @cur = t.location.start_pos
-            write_type(io, "#{position}_#{name}_#{i}", t, accuracy)
+            write_type(io, "#{position}_#{name}_#{i}", t)
           end
         when ::RBS::Types::Optional
           raise unless type.location
 
-          write_type(io, "#{position}_optional_left", type.type, accuracy)
+          write_type(io, "#{position}_optional_left", type.type)
           io.write(slice(@cur, @cur...(type.location.end_pos - 1)))
           @cur = type.location.end_pos - 1
           if @cov.include?("#{position}_optional_right".to_sym)
@@ -103,17 +103,6 @@ module RaaP
           end
           raise unless type.location
 
-          @cur = type.location.end_pos
-        when ::RBS::Types::Variable
-          case accuracy
-          when :abs
-            io.write(green(type.name.to_s))
-          when :opt
-            # Variables are substed so raap don't know if they've been used.
-            io.write(yellow(type.name.to_s))
-          end
-          raise unless type.location
-
           @cur = type.location.end_pos
         else
           raise unless type.location
@@ -129,7 +118,6 @@ module RaaP
 
       def green(str) = "\e[32m#{str}\e[0m"
       def red(str) = "\e[1;4;41m#{str}\e[0m"
-      def yellow(str) = "\e[93m#{str}\e[0m"
     end
 
     class << self
@@ -142,8 +130,6 @@ module RaaP
         !!@cov
       end
 
-      # position: req_0
-      # type: union_1
       def log(position)
         return unless running?
 
@@ -151,7 +137,7 @@ module RaaP
       end
 
       def cov
-        @cov or raise
+        @cov or raise("Coverage is not started")
       end
 
       def show(io)
@@ -162,25 +148,31 @@ module RaaP
       end
 
       def new_type_with_log(position, type)
+        log_with_type(position, type) do |t|
+          Type.new(t)
+        end
+      end
+
+      def log_with_type(position, type, &block)
         case type
         when ::RBS::Types::Tuple
           # FIXME: Support Union in Tuple
           type.types.each_with_index do |_t, i|
             log("#{position}_tuple_#{i}")
           end
-          Type.new(type)
+          block&.call(type)
         when ::RBS::Types::Union
           i = Random.rand(type.types.length)
-          new_type_with_log("#{position}_union_#{i}", type.types[i])
+          log_with_type("#{position}_union_#{i}", type.types[i], &block)
         when ::RBS::Types::Optional
           if Random.rand(2).zero?
-            new_type_with_log("#{position}_optional_left", type.type)
+            log_with_type("#{position}_optional_left", type.type, &block)
           else
-            new_type_with_log("#{position}_optional_right", ::RBS::Types::Bases::Nil.new(location: nil))
+            log_with_type("#{position}_optional_right", ::RBS::Types::Bases::Nil.new(location: nil), &block)
           end
         else
           log(position)
-          Type.new(type)
+          block&.call(type)
         end
       end
     end

data/lib/raap/function_type.rb

@@ -2,8 +2,9 @@
 
 module RaaP
   class FunctionType
-    def initialize(fun)
+    def initialize(fun, coverage: true)
       @fun = fun
+      @coverage = coverage
     end
 
     def pick_arguments(size: 10)
@@ -81,7 +82,11 @@ module RaaP
     end
 
     def build_type_with_coverage(position, param)
-      Coverage.new_type_with_log(position, param.type)
+      if @coverage
+        Coverage.new_type_with_log(position, param.type)
+      else
+        Type.new(param.type)
+      end
     end
   end
 end

data/lib/raap/method_property.rb

@@ -50,7 +50,7 @@ module RaaP
     private
 
     def call(size:, stats:)
-      if @method_type.rbs.type.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) }
+      if @method_type.rbs.type.each_param.find { |param| param.type.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) } }
         RaaP.logger.info { "Skip type check since `#{@method_type.rbs}` includes `untyped`" }
         stats.break = true
         throw :break

data/lib/raap/method_type.rb

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

data/lib/raap/value/interface.rb

@@ -33,7 +33,7 @@ module RaaP
               if b && subed_method_type.block && subed_method_type.block.type.is_a?(::RBS::Types::Function)
                 @fixed_block_arguments ||= {}
                 @fixed_block_arguments[name] ||= size.times.map do
-                  FunctionType.new(subed_method_type.block.type)
+                  FunctionType.new(subed_method_type.block.type, coverage: false)
                               .pick_arguments(size: size)
                 end
 

data/lib/raap/version.rb

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

data/sig/raap.rbs

@@ -19,21 +19,15 @@ module RaaP
 
   class CLI
     class Option < ::Struct[untyped]
-      def self.new: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance
+      def self.new: (?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance
 
-      def self.[]: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance
+      def self.[]: (?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance
 
       def self.keyword_init?: () -> true
 
-      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
+      def self.members: () -> [ :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
 
-      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
-
-      attr_accessor dirs: ::Array[String]
-
-      attr_accessor requires: ::Array[String]
-
-      attr_accessor libraries: ::Array[String]
+      def members: () -> [ :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
 
       attr_accessor timeout: (Integer | Float | nil)
 
@@ -75,7 +69,6 @@ module RaaP
 
   module Coverage
     type locs = [::RBS::Buffer::loc, ::RBS::Buffer::loc]
-    type accuracy = :abs | :opt
     class Writer
       @method_type: ::RBS::MethodType
       @cov: ::Set[Symbol]
@@ -88,11 +81,10 @@ module RaaP
 
       def method_type_location: () -> ::RBS::Location[untyped, untyped]
       def slice: (Integer, Range[Integer]) -> String
-      def write_param: (IO, String, ::RBS::Types::Function::Param, accuracy) -> void
-      def write_type: (IO, String, ::RBS::Types::t, accuracy) -> void
+      def write_param: (IO, String, ::RBS::Types::Function::Param) -> void
+      def write_type: (IO, String, ::RBS::Types::t) -> void
       def green: (String) -> String
       def red: (String) -> String
-      def yellow: (String) -> String
     end
 
     self.@cov: Set[Symbol]?
@@ -104,12 +96,15 @@ module RaaP
     def self.cov: () -> Set[Symbol]
     def self.show: (IO) -> void
     def self.new_type_with_log: (String, ::RBS::Types::t) -> Type
+    def self.log_with_type: (String, ::RBS::Types::t) -> nil
+                          | (String, ::RBS::Types::t) ?{ (::RBS::Types::t) -> Type } -> Type
   end
 
   class FunctionType
     @fun: ::RBS::Types::Function
+    @coverage: boolish
 
-    def initialize: (::RBS::Types::Function) -> void
+    def initialize: (::RBS::Types::Function, ?coverage: boolish) -> void
     def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
     def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
 
@@ -150,8 +145,8 @@ module RaaP
 
   class MethodType
     attr_reader rbs: ::RBS::MethodType
-    attr_reader original_rbs: ::RBS::MethodType
     @fun_type: FunctionType
+    @type_check: ::RBS::Test::TypeCheck
 
     def initialize: (::RBS::MethodType | String method, ?type_params_decl: Array[untyped], ?type_args: Array[untyped], ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> void
     def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-08 00:00:00.000000000 Z
+date: 2024-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs