steep 0.16.0 → 0.16.1

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

@@ -1,61 +0,0 @@
-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/vendor/ruby-signature/lib/rbs/test/hook.rb

@@ -1,294 +0,0 @@
-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/vendor/ruby-signature/lib/rbs/test/setup.rb

@@ -1,58 +0,0 @@
-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/vendor/ruby-signature/lib/rbs/test/spy.rb

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