rbs 0.2.0

data/lib/rbs/test/errors.rb

@@ -0,0 +1,61 @@
+module RBS
+  module Test
+    module Errors
+      ArgumentTypeError =
+        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
+      BlockArgumentTypeError =
+        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
+      ArgumentError =
+        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      BlockArgumentError =
+        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      ReturnTypeError =
+        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
+      BlockReturnTypeError =
+        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
+
+      UnexpectedBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      MissingBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+
+      UnresolvedOverloadingError = Struct.new(:klass, :method_name, :method_types, keyword_init: true)
+
+      def self.format_param(param)
+        if param.name
+          "`#{param.type}` (#{param.name})"
+        else
+          "`#{param.type}`"
+        end
+      end
+
+      def self.inspect_(obj)
+        Hook.inspect_(obj)
+      end
+
+      def self.to_string(error)
+        method = "#{error.klass.name}#{error.method_name}"
+        case error
+        when ArgumentTypeError
+          "[#{method}] ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+        when BlockArgumentTypeError
+          "[#{method}] BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+        when ArgumentError
+          "[#{method}] ArgumentError: expected method type #{error.method_type}"
+        when BlockArgumentError
+          "[#{method}] BlockArgumentError: expected method type #{error.method_type}"
+        when ReturnTypeError
+          "[#{method}] ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+        when BlockReturnTypeError
+          "[#{method}] BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+        when UnexpectedBlockError
+          "[#{method}] UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
+        when MissingBlockError
+          "[#{method}] MissingBlockError: required block is missing for `#{error.method_type}`"
+        when UnresolvedOverloadingError
+          "[#{method}] UnresolvedOverloadingError: couldn't find a suitable overloading"
+        else
+          raise "Unexpected error: #{inspect_(error)}"
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/hook.rb

@@ -0,0 +1,294 @@
+require "rbs"
+require "pp"
+
+module RBS
+  module Test
+    class Hook
+      class Error < Exception
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors
+          super "Type error detected: [#{errors.map {|e| Errors.to_string(e) }.join(", ")}]"
+        end
+      end
+
+      attr_reader :env
+      attr_reader :logger
+
+      attr_reader :instance_module
+      attr_reader :instance_methods
+      attr_reader :singleton_module
+      attr_reader :singleton_methods
+
+      attr_reader :klass
+      attr_reader :errors
+
+      def builder
+        @builder ||= DefinitionBuilder.new(env: env)
+      end
+
+      def typecheck
+        @typecheck ||= TypeCheck.new(self_class: klass, builder: builder)
+      end
+
+      def initialize(env, klass, logger:, raise_on_error: false)
+        @env = env
+        @logger = logger
+        @klass = klass
+
+        @instance_module = Module.new
+        @instance_methods = []
+
+        @singleton_module = Module.new
+        @singleton_methods = []
+
+        @errors = []
+
+        @raise_on_error = raise_on_error
+      end
+
+      def raise_on_error!(error = true)
+        @raise_on_error = error
+        self
+      end
+
+      def raise_on_error?
+        @raise_on_error
+      end
+
+      def prepend!
+        klass.prepend @instance_module
+        klass.singleton_class.prepend @singleton_module
+
+        if block_given?
+          yield
+          disable
+        end
+
+        self
+      end
+
+      def self.install(env, klass, logger:)
+        new(env, klass, logger: logger).prepend!
+      end
+
+      def refinement
+        klass = self.klass
+        instance_module = self.instance_module
+        singleton_module = self.singleton_module
+
+        Module.new do
+          refine klass do
+            prepend instance_module
+          end
+
+          refine klass.singleton_class do
+            prepend singleton_module
+          end
+        end
+      end
+
+      def verify_all
+        type_name = Namespace.parse(klass.name).to_type_name.absolute!
+
+        builder.build_instance(type_name).tap do |definition|
+          definition.methods.each do |name, method|
+            if method.defined_in.name.absolute! == type_name
+              unless method.annotations.any? {|a| a.string == "rbs:test:skip" }
+                logger.info "Installing a hook on #{type_name}##{name}: #{method.method_types.join(" | ")}"
+                verify instance_method: name, types: method.method_types
+              else
+                logger.info "Skipping test of #{type_name}##{name}"
+              end
+            end
+          end
+        end
+
+        builder.build_singleton(type_name).tap do |definition|
+          definition.methods.each do |name, method|
+            if method.defined_in&.name&.absolute! == type_name || name == :new
+              unless method.annotations.any? {|a| a.string == "rbs:test:skip" }
+                logger.info "Installing a hook on #{type_name}.#{name}: #{method.method_types.join(" | ")}"
+                verify singleton_method: name, types: method.method_types
+              else
+                logger.info "Skipping test of #{type_name}.#{name}"
+              end
+            end
+          end
+        end
+
+        self
+      end
+
+      def delegation(name, method_types, method_name)
+        hook = self
+
+        -> (*args, &block) do
+          hook.logger.debug { "#{method_name} receives arguments: #{hook.inspect_(args)}" }
+
+          block_calls = []
+
+          if block
+            original_block = block
+
+            block = hook.call(Object.new, INSTANCE_EVAL) do |fresh_obj|
+              ->(*as) do
+                hook.logger.debug { "#{method_name} receives block arguments: #{hook.inspect_(as)}" }
+
+                ret = if self.equal?(fresh_obj)
+                        original_block[*as]
+                      else
+                        hook.call(self, INSTANCE_EXEC, *as, &original_block)
+                      end
+
+                block_calls << ArgumentsReturn.new(
+                  arguments: as,
+                  return_value: ret,
+                  exception: nil
+                )
+
+                hook.logger.debug { "#{method_name} returns from block: #{hook.inspect_(ret)}" }
+
+                ret
+              end.ruby2_keywords
+            end
+          end
+
+          method = hook.call(self, METHOD, name)
+          klass = hook.call(self, CLASS)
+          singleton_klass = begin
+            hook.call(self, SINGLETON_CLASS)
+          rescue TypeError
+            nil
+          end
+          prepended = klass.ancestors.include?(hook.instance_module) || singleton_klass&.ancestors&.include?(hook.singleton_module)
+          exception = nil
+          result = begin
+             if prepended
+               method.super_method.call(*args, &block)
+             else
+               # Using refinement
+               method.call(*args, &block)
+             end
+          rescue Exception => e
+            exception = e
+            nil
+          end
+
+          hook.logger.debug { "#{method_name} returns: #{hook.inspect_(result)}" }
+
+          call = CallTrace.new(method_call: ArgumentsReturn.new(arguments: args, return_value: result, exception: exception),
+                               block_calls: block_calls,
+                               block_given: block != nil)
+
+          method_type_errors = method_types.map do |method_type|
+            hook.typecheck.method_call(method_name, method_type, call, errors: [])
+          end
+
+          new_errors = []
+
+          if method_type_errors.none?(&:empty?)
+            if (best_errors = hook.find_best_errors(method_type_errors))
+              new_errors.push(*best_errors)
+            else
+              new_errors << Errors::UnresolvedOverloadingError.new(
+                klass: hook.klass,
+                method_name: method_name,
+                method_types: method_types
+              )
+            end
+          end
+
+          unless new_errors.empty?
+            new_errors.each do |error|
+              hook.logger.error Errors.to_string(error)
+            end
+
+            hook.errors.push(*new_errors)
+
+            if hook.raise_on_error?
+              raise Error.new(new_errors)
+            end
+          end
+
+          result
+        end.ruby2_keywords
+      end
+
+      def verify(instance_method: nil, singleton_method: nil, types:)
+        method_types = types.map do |type|
+          case type
+          when String
+            Parser.parse_method_type(type)
+          else
+            type
+          end
+        end
+
+        case
+        when instance_method
+          instance_methods << instance_method
+          call(self.instance_module, DEFINE_METHOD, instance_method, &delegation(instance_method, method_types, "##{instance_method}"))
+        when singleton_method
+          call(self.singleton_module, DEFINE_METHOD, singleton_method, &delegation(singleton_method, method_types, ".#{singleton_method}"))
+        end
+
+        self
+      end
+
+      def find_best_errors(errorss)
+        if errorss.size == 1
+          errorss[0]
+        else
+          no_arity_errors = errorss.select do |errors|
+            errors.none? do |error|
+              error.is_a?(Errors::ArgumentError) ||
+                error.is_a?(Errors::BlockArgumentError) ||
+                error.is_a?(Errors::MissingBlockError) ||
+                error.is_a?(Errors::UnexpectedBlockError)
+            end
+          end
+
+          unless no_arity_errors.empty?
+            # Choose a error set which doesn't include arity error
+            return no_arity_errors[0] if no_arity_errors.size == 1
+          end
+        end
+      end
+
+      def self.backtrace(skip: 2)
+        raise
+      rescue => exn
+        exn.backtrace.drop(skip)
+      end
+
+      def run
+        yield
+        self
+      ensure
+        disable
+      end
+
+      def call(receiver, method, *args, &block)
+        method.bind(receiver).call(*args, &block)
+      end
+
+      def inspect_(obj)
+        Hook.inspect_(obj)
+      end
+
+      def self.inspect_(obj)
+        obj.inspect
+      rescue
+        INSPECT.bind(obj).call()
+      end
+
+      def disable
+        self.instance_module.remove_method(*instance_methods)
+        self.singleton_module.remove_method(*singleton_methods)
+        self
+      end
+    end
+  end
+end

data/lib/rbs/test/setup.rb

@@ -0,0 +1,58 @@
+require "rbs"
+require "rbs/test"
+
+require "optparse"
+require "shellwords"
+
+logger = Logger.new(STDERR)
+
+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"]
+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"
+  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)
+
+def match(filter, name)
+  if filter.end_with?("*")
+    name.start_with?(filter[0, filter.size - 1]) || name == filter[0, filter.size-3]
+  else
+    filter == name
+  end
+end
+
+TracePoint.trace :end do |tp|
+  class_name = tp.self.name
+
+  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)
+          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)
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/spy.rb

@@ -0,0 +1,325 @@
+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