rbs 0.2.0 → 0.6.0

data/lib/rbs/test/observer.rb

@@ -0,0 +1,17 @@
+module RBS
+  module Test
+    module Observer
+      @@observers = {}
+
+      class <<self
+        def notify(key, *args)
+          @@observers[key]&.call(*args)
+        end
+
+        def register(key, object = nil, &block)
+          @@observers[key] = object || block
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/setup.rb

@@ -10,28 +10,25 @@ begin
   opts = Shellwords.shellsplit(ENV["RBS_TEST_OPT"] || "-I sig")
   filter = ENV.fetch("RBS_TEST_TARGET").split(",")
   skips = (ENV["RBS_TEST_SKIP"] || "").split(",")
-  logger.level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
-  raise_on_error = ENV["RBS_TEST_RAISE"]
+  sampling = !ENV.key?("RBS_TEST_NO_SAMPLE")
+  RBS.logger_level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
 rescue
   STDERR.puts "rbs/test/setup handles the following environment variables:"
   STDERR.puts "  [REQUIRED] RBS_TEST_TARGET: test target class name, `Foo::Bar,Foo::Baz` for each class or `Foo::*` for all classes under `Foo`"
   STDERR.puts "  [OPTIONAL] RBS_TEST_SKIP: skip testing classes"
   STDERR.puts "  [OPTIONAL] RBS_TEST_OPT: options for signatures (`-r` for libraries or `-I` for signatures)"
   STDERR.puts "  [OPTIONAL] RBS_TEST_LOGLEVEL: one of debug|info|warn|error|fatal (defaults to info)"
-  STDERR.puts "  [OPTIONAL] RBS_TEST_RAISE: specify any value to raise an exception when type error is detected"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_NO_SAMPLE: if set, the type checker tests all the values of a collection"
   exit 1
 end
 
-hooks = []
-
-env = RBS::Environment.new
-
 loader = RBS::EnvironmentLoader.new
 OptionParser.new do |opts|
   opts.on("-r [LIB]") do |name| loader.add(library: name) end
   opts.on("-I [DIR]") do |dir| loader.add(path: Pathname(dir)) end
 end.parse!(opts)
-loader.load(env: env)
+
+env = RBS::Environment.from_loader(loader).resolve_type_names
 
 def match(filter, name)
   if filter.end_with?("*")
@@ -41,16 +38,18 @@ def match(filter, name)
   end
 end
 
+factory = RBS::Factory.new()
+tester = RBS::Test::Tester.new(env: env)
+
 TracePoint.trace :end do |tp|
-  class_name = tp.self.name
+  class_name = tp.self.name&.yield_self {|name| factory.type_name(name).absolute! }
 
   if class_name
-    if filter.any? {|f| match(f, class_name) } && skips.none? {|f| match(f, class_name) }
-      type_name = RBS::Namespace.parse(class_name).absolute!.to_type_name
-      if hooks.none? {|hook| hook.klass == tp.self }
-        if env.find_class(type_name)
+    if filter.any? {|f| match(f, class_name.to_s) } && skips.none? {|f| match(f, class_name.to_s) }
+      if tester.checkers.none? {|hook| hook.klass == tp.self }
+        if env.class_decls.key?(class_name)
           logger.info "Setting up hooks for #{class_name}"
-          hooks << RBS::Test::Hook.install(env, tp.self, logger: logger).verify_all.raise_on_error!(raise_on_error)
+          tester.install!(tp.self, sampling: sampling)
         end
       end
     end

data/lib/rbs/test/spy.rb

@@ -1,325 +1,4 @@
 module RBS
   module Test
-    module Spy
-      def self.singleton_method(object, method_name)
-        spy = SingletonSpy.new(object: object, method_name: method_name)
-
-        if block_given?
-          begin
-            spy.setup
-            yield spy
-          ensure
-            spy.reset
-          end
-        else
-          spy
-        end
-      end
-
-      def self.instance_method(mod, method_name)
-        spy = InstanceSpy.new(mod: mod, method_name: method_name)
-
-        if block_given?
-          begin
-            spy.setup
-            yield spy
-          ensure
-            spy.reset
-          end
-        else
-          spy
-        end
-      end
-
-      def self.wrap(object, method_name)
-        spy = WrapSpy.new(object: object, method_name: method_name)
-
-        if block_given?
-          begin
-            yield spy, spy.wrapped_object
-          end
-        else
-          spy
-        end
-      end
-
-      class SingletonSpy
-        attr_accessor :callback
-        attr_reader :method_name
-        attr_reader :object
-
-        def initialize(object:, method_name:)
-          @object = object
-          @method_name = method_name
-          @callback = -> (_) { }
-        end
-
-        def setup
-          spy = self
-
-          object.singleton_class.class_eval do
-            remove_method spy.method_name
-            define_method spy.method_name, spy.spy()
-          end
-        end
-
-        def spy()
-          spy = self
-
-          -> (*args, &block) do
-            return_value = nil
-            exception = nil
-            block_calls = []
-
-            spy_block = if block
-                          Object.new.instance_eval do |fresh|
-                            -> (*block_args) do
-                              block_exn = nil
-                              block_return = nil
-
-                              begin
-                                block_return = if self.equal?(fresh)
-                                                 # no instance eval
-                                                 block.call(*block_args)
-                                               else
-                                                 self.instance_exec(*block_args, &block)
-                                               end
-                              rescue Exception => exn
-                                block_exn = exn
-                              end
-
-                              block_calls << ArgumentsReturn.new(
-                                arguments: block_args,
-                                return_value: block_return,
-                                exception: block_exn
-                              )
-
-                              if block_exn
-                                raise block_exn
-                              else
-                                block_return
-                              end
-                            end.ruby2_keywords
-                          end
-                        end
-
-            begin
-              return_value = super(*args, &spy_block)
-            rescue Exception => exn
-              exception = exn
-            end
-
-            trace = CallTrace.new(
-              method_name: spy.method_name,
-              method_call: ArgumentsReturn.new(
-                arguments: args,
-                return_value: return_value,
-                exception: exception,
-              ),
-              block_calls: block_calls,
-              block_given: block != nil
-            )
-
-            spy.callback.call(trace)
-
-            if exception
-              raise exception
-            else
-              return_value
-            end
-          end.ruby2_keywords
-        end
-
-        def reset
-          if object.singleton_class.methods.include?(method_name)
-            object.singleton_class.remove_method method_name
-          end
-        end
-      end
-
-      class InstanceSpy
-        attr_accessor :callback
-        attr_reader :mod
-        attr_reader :method_name
-        attr_reader :original_method
-
-        def initialize(mod:, method_name:)
-          @mod = mod
-          @method_name = method_name
-          @original_method = mod.instance_method(method_name)
-          @callback = -> (_) { }
-        end
-
-        def setup
-          spy = self
-
-          mod.class_eval do
-            remove_method spy.method_name
-            define_method spy.method_name, spy.spy()
-          end
-        end
-
-        def reset
-          spy = self
-
-          mod.class_eval do
-            remove_method spy.method_name
-            define_method spy.method_name, spy.original_method
-          end
-        end
-
-        def spy
-          spy = self
-
-          -> (*args, &block) do
-            return_value = nil
-            exception = nil
-            block_calls = []
-
-            spy_block = if block
-                          Object.new.instance_eval do |fresh|
-                            -> (*block_args) do
-                              block_exn = nil
-                              block_return = nil
-
-                              begin
-                                block_return = if self.equal?(fresh)
-                                                 # no instance eval
-                                                 block.call(*block_args)
-                                               else
-                                                 self.instance_exec(*block_args, &block)
-                                               end
-                              rescue Exception => exn
-                                block_exn = exn
-                              end
-
-                              block_calls << ArgumentsReturn.new(
-                                arguments: block_args,
-                                return_value: block_return,
-                                exception: block_exn
-                              )
-
-                              if block_exn
-                                raise block_exn
-                              else
-                                block_return
-                              end
-                            end.ruby2_keywords
-                          end
-                        end
-
-            begin
-              return_value = spy.original_method.bind_call(self, *args, &spy_block)
-            rescue Exception => exn
-              exception = exn
-            end
-
-            trace = CallTrace.new(
-              method_name: spy.method_name,
-              method_call: ArgumentsReturn.new(
-                arguments: args,
-                return_value: return_value,
-                exception: exception,
-                ),
-              block_calls: block_calls,
-              block_given: block != nil
-            )
-
-            spy.callback.call(trace)
-
-            if exception
-              raise exception
-            else
-              return_value
-            end
-          end.ruby2_keywords
-        end
-      end
-
-      class WrapSpy
-        attr_accessor :callback
-        attr_reader :object
-        attr_reader :method_name
-
-        def initialize(object:, method_name:)
-          @callback = -> (_) { }
-          @object = object
-          @method_name = method_name
-        end
-
-        def wrapped_object
-          spy = self
-
-          Class.new(BasicObject) do
-            define_method(:method_missing) do |name, *args, &block|
-              spy.object.__send__(name, *args, &block)
-            end
-
-            define_method(spy.method_name, -> (*args, &block) {
-              return_value = nil
-              exception = nil
-              block_calls = []
-
-              spy_block = if block
-                            Object.new.instance_eval do |fresh|
-                              -> (*block_args) do
-                                block_exn = nil
-                                block_return = nil
-
-                                begin
-                                  block_return = if self.equal?(fresh)
-                                                   # no instance eval
-                                                   block.call(*block_args)
-                                                 else
-                                                   self.instance_exec(*block_args, &block)
-                                                 end
-                                rescue Exception => exn
-                                  block_exn = exn
-                                end
-
-                                block_calls << ArgumentsReturn.new(
-                                  arguments: block_args,
-                                  return_value: block_return,
-                                  exception: block_exn
-                                )
-
-                                if block_exn
-                                  raise block_exn
-                                else
-                                  block_return
-                                end
-                              end.ruby2_keywords
-                            end
-                          end
-
-              begin
-                return_value = spy.object.__send__(spy.method_name, *args, &spy_block)
-              rescue ::Exception => exn
-                exception = exn
-              end
-
-              trace = CallTrace.new(
-                method_name: spy.method_name,
-                method_call: ArgumentsReturn.new(
-                  arguments: args,
-                  return_value: return_value,
-                  exception: exception,
-                  ),
-                block_calls: block_calls,
-                block_given: block != nil
-              )
-
-              spy.callback.call(trace)
-
-              if exception
-                spy.object.__send__(:raise, exception)
-              else
-                return_value
-              end
-            }.ruby2_keywords)
-          end.new()
-        end
-      end
-    end
   end
 end

data/lib/rbs/test/tester.rb

@@ -0,0 +1,116 @@
+module RBS
+  module Test
+    class Tester
+      attr_reader :env
+      attr_reader :checkers
+
+      def initialize(env:)
+        @env = env
+        @checkers = []
+      end
+
+      def factory
+        @factory ||= Factory.new
+      end
+
+      def builder
+        @builder ||= DefinitionBuilder.new(env: env)
+      end
+
+      def install!(klass, sampling:)
+        RBS.logger.info { "Installing runtime type checker in #{klass}..." }
+
+        type_name = factory.type_name(klass.name).absolute!
+
+        builder.build_instance(type_name).tap do |definition|
+          instance_key = new_key(type_name, "InstanceChecker")
+          Observer.register(instance_key, MethodCallTester.new(klass, builder, definition, kind: :instance, sampling: sampling))
+
+          definition.methods.each do |name, method|
+            if method.implemented_in == type_name
+              RBS.logger.info { "Setting up method hook in ##{name}..." }
+              Hook.hook_instance_method klass, name, key: instance_key
+            end
+          end
+        end
+
+        builder.build_singleton(type_name).tap do |definition|
+          singleton_key = new_key(type_name, "SingletonChecker")
+          Observer.register(singleton_key, MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sampling: sampling))
+
+          definition.methods.each do |name, method|
+            if method.implemented_in == type_name || name == :new
+              RBS.logger.info { "Setting up method hook in .#{name}..." }
+              Hook.hook_singleton_method klass, name, key: singleton_key
+            end
+          end
+        end
+      end
+
+      def new_key(type_name, prefix)
+        "#{prefix}__#{type_name}__#{SecureRandom.hex(10)}"
+      end
+
+      class TypeError < Exception
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors
+
+          super "TypeError: #{errors.map {|e| Errors.to_string(e) }.join(", ")}"
+        end
+      end
+
+      class MethodCallTester
+        attr_reader :self_class
+        attr_reader :definition
+        attr_reader :builder
+        attr_reader :kind
+        attr_reader :sampling
+
+        def initialize(self_class, builder, definition, kind:, sampling:)
+          @self_class = self_class
+          @definition = definition
+          @builder = builder
+          @kind = kind
+          @sampling = sampling
+        end
+
+        def env
+          builder.env
+        end
+
+        def check
+          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sampling: sampling)
+        end
+
+        def format_method_name(name)
+          case kind
+          when :instance
+            "##{name}"
+          when :singleton
+            ".#{name}"
+          end
+        end
+
+        def call(receiver, trace)
+          method_name = trace.method_name
+          method = definition.methods[method_name]
+          if method
+            RBS.logger.debug { "Type checking `#{self_class}#{format_method_name(method_name)}`..."}
+            errors = check.overloaded_call(method, format_method_name(method_name), trace, errors: [])
+
+            if errors.empty?
+              RBS.logger.debug { "No type error detected 👏" }
+            else
+              RBS.logger.debug { "Detected type error 🚨" }
+              raise TypeError.new(errors)
+            end
+          else
+            RBS.logger.error { "Type checking `#{self_class}#{method_name}` call but no method found in definition" }
+          end
+        end
+      end
+    end
+  end
+end