rbs 0.4.0 → 0.9.0

data/lib/rbs/test/errors.rb

@@ -28,7 +28,11 @@ module RBS
       end
 
       def self.inspect_(obj)
-        Hook.inspect_(obj)
+        if obj.respond_to?(:inspect)
+          obj.inspect
+        else
+          Test::INSPECT.bind(obj).call     # For the case inspect is not defined (like BasicObject)
+        end
       end
 
       def self.to_string(error)

data/lib/rbs/test/hook.rb

@@ -3,291 +3,165 @@ 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
+    module Hook
+      OPERATORS = {
+        :== => "eqeq",
+        :=== => "eqeqeq",
+        :+ => "plus",
+        :- => "minus",
+        :* => "star",
+        :/ => "slash",
+        :> => "gt",
+        :>= => "gteq",
+        :< => "lt",
+        :<= => "lteq",
+        :<=> => "ufo",
+        :& => "amp",
+        :| => "vbar",
+        :^ => "hat",
+        :! => "not",
+        :<< => "lshift",
+        :>> => "rshift",
+        :~ => "tilda"
+      }
+      def self.alias_names(target)
+        case target
+        when *OPERATORS.keys
+          name = OPERATORS[target]
+          [
+            "#{name}____with__#{Test.suffix}",
+            "#{name}____without__#{Test.suffix}"
+          ]
+        else
+          aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
 
-        if block_given?
-          yield
-          disable
+          [
+            "#{aliased_target}__with__#{Test.suffix}#{punctuation}",
+            "#{aliased_target}__without__#{Test.suffix}#{punctuation}"
+          ]
         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 self.setup_alias_method_chain(klass, target)
+        with_method, without_method = alias_names(target)
 
-      def verify_all
-        type_name = Namespace.parse(klass.name).to_type_name.absolute!
+        RBS.logger.debug "alias name: #{target}, #{with_method}, #{without_method}"
 
-        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
+        klass.instance_eval do
+          alias_method without_method, target
+          alias_method target, with_method
 
-        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
+          case
+          when public_method_defined?(without_method)
+            public target
+          when protected_method_defined?(without_method)
+            protected target
+          when private_method_defined?(without_method)
+            private target
           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)
+      def self.hook_method_source(prefix, method_name, key)
+        with_name, without_name = alias_names(method_name)
+        full_method_name = "#{prefix}#{method_name}"
+
+        [__LINE__ + 1, <<RUBY]
+def #{with_name}(*args)
+  ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
+
+  begin
+    return_from_call = false
+    block_calls = []
+
+    if block_given?
+      result = __send__(:"#{without_name}", *args) do |*block_args|
+        return_from_block = false
+
+        begin
+          block_result = yield(*block_args)
+          return_from_block = true
+        ensure
+          exn = $!
+
+          case
+          when return_from_block
+            # Returned from yield
+            block_calls << ::RBS::Test::ArgumentsReturn.return(
+              arguments: block_args,
+              value: block_result
+            )
+          when exn
+            # Exception
+            block_calls << ::RBS::Test::ArgumentsReturn.exception(
+              arguments: block_args,
+              exception: exn
+            )
           else
-            type
+            # break?
+            block_calls << ::RBS::Test::ArgumentsReturn.break(
+              arguments: block_args
+            )
           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
+        block_result
       end
+    else
+      result = __send__(:"#{without_name}", *args)
+    end
+    return_from_call = true
+    result
+  ensure
+    exn = $!
+
+    case
+    when return_from_call
+      ::RBS.logger.debug { "#{full_method_name} return with value: " + result.inspect }
+      method_call = ::RBS::Test::ArgumentsReturn.return(
+        arguments: args,
+        value: result
+      )
+    when exn
+      ::RBS.logger.debug { "#{full_method_name} exit with exception: " + exn.inspect }
+      method_call = ::RBS::Test::ArgumentsReturn.exception(
+        arguments: args,
+        exception: exn
+      )
+    else
+      ::RBS.logger.debug { "#{full_method_name} exit with jump" }
+      method_call = ::RBS::Test::ArgumentsReturn.break(arguments: args)
+    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
+    trace = ::RBS::Test::CallTrace.new(
+      method_name: #{method_name.inspect},
+      method_call: method_call,
+      block_calls: block_calls,
+      block_given: block_given?,
+    )
 
-          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
+    ::RBS::Test::Observer.notify(#{key.inspect}, self, trace)
+  end
 
-      def self.backtrace(skip: 2)
-        raise
-      rescue => exn
-        exn.backtrace.drop(skip)
-      end
+  result
+end
 
-      def run
-        yield
-        self
-      ensure
-        disable
+ruby2_keywords :#{with_name}
+RUBY
       end
 
-      def call(receiver, method, *args, &block)
-        method.bind(receiver).call(*args, &block)
-      end
+      def self.hook_instance_method(klass, method, key:)
+        line, source = hook_method_source("#{klass}#", method, key)
 
-      def inspect_(obj)
-        Hook.inspect_(obj)
+        klass.module_eval(source, __FILE__, line)
+        setup_alias_method_chain klass, method
       end
 
-      def self.inspect_(obj)
-        obj.inspect
-      rescue
-        INSPECT.bind(obj).call()
-      end
+      def self.hook_singleton_method(klass, method, key:)
+        line, source = hook_method_source("#{klass}.",method, key)
 
-      def disable
-        self.instance_module.remove_method(*instance_methods)
-        self.singleton_module.remove_method(*singleton_methods)
-        self
+        klass.singleton_class.module_eval(source, __FILE__, line)
+        setup_alias_method_chain klass.singleton_class, method
       end
     end
   end

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