steep 0.11.1 → 0.12.0

data/vendor/ruby-signature/lib/ruby/signature/test/errors.rb

@@ -0,0 +1,63 @@
+module Ruby
+  module Signature
+    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
+end

data/vendor/ruby-signature/lib/ruby/signature/test/hook.rb

@@ -0,0 +1,290 @@
+require "ruby/signature"
+require "pp"
+
+module Ruby
+  module Signature
+    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)
+            result = if prepended
+                       method.super_method.call(*args, &block)
+                     else
+                       # Using refinement
+                       method.call(*args, &block)
+                     end
+
+            hook.logger.debug { "#{method_name} returns: #{hook.inspect_(result)}" }
+
+            call = CallTrace.new(method_call: ArgumentsReturn.new(arguments: args, return_value: result, exception: nil),
+                                 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
+end

data/vendor/ruby-signature/lib/ruby/signature/test/setup.rb

@@ -0,0 +1,58 @@
+require "ruby/signature"
+require "ruby/signature/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 "ruby/signature/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 = Ruby::Signature::Environment.new
+
+loader = Ruby::Signature::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 = Ruby::Signature::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 << Ruby::Signature::Test::Hook.install(env, tp.self, logger: logger).verify_all.raise_on_error!(raise_on_error)
+        end
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/ruby/signature/test/spy.rb

@@ -0,0 +1,324 @@
+module Ruby
+  module Signature
+    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
+              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
+              define_method spy.method_name, spy.spy()
+            end
+          end
+
+          def reset
+            spy = self
+
+            mod.class_eval do
+              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
+end