steep 0.14.0 → 0.16.3

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

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

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

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

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