rbs-relaxed 3.9.0.1

data/lib/rbs/unit_test/convertibles.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RBS
+  module UnitTest
+    module Convertibles
+      class BlankSlate < BasicObject
+        instance_methods.each do |im|
+          next if im == :__send__
+          undef_method im
+        end
+
+        def __with_object_methods(*methods)
+          methods.each do |method|
+            singleton_class = ::Object.instance_method(:singleton_class).bind_call(self) #: Class
+            singleton_class.instance_eval do
+              define_method method, ::Object.instance_method(method)
+            end
+          end
+          self
+        end
+      end
+
+      class ToIO < BlankSlate
+        def initialize(io = $stdout)
+          @io = io
+        end
+
+        def to_io
+          @io
+        end
+      end
+
+      class ToI < BlankSlate
+        def initialize(value = 3)
+          @value = value
+        end
+
+        def to_i
+          @value
+        end
+      end
+
+      class ToInt < BlankSlate
+        def initialize(value = 3)
+          @value = value
+        end
+
+        def to_int
+          @value
+        end
+      end
+
+      class ToF < BlankSlate
+        def initialize(value = 0.1)
+          @value = value
+        end
+
+        def to_f
+          @value
+        end
+      end
+
+      class ToR < BlankSlate
+        def initialize(value = 1r)
+          @value = value
+        end
+
+        def to_r
+          @value
+        end
+      end
+
+      class ToC < BlankSlate
+        def initialize(value = 1i)
+          @value = value
+        end
+
+        def to_c
+          @value
+        end
+      end
+
+      class ToStr < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_str
+          @value
+        end
+      end
+
+      class ToS < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_s
+          @value
+        end
+      end
+
+      class ToSym < BlankSlate
+        def initialize(value = :&)
+          @value = value
+        end
+
+        def to_sym
+          @value
+        end
+      end
+
+      class ToA < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def to_a
+          @args
+        end
+      end
+
+      class ToArray < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def to_ary
+          @args
+        end
+      end
+
+      class ToHash < BlankSlate
+        def initialize(hash = { 'hello' => 'world' })
+          @hash = hash
+        end
+
+        def to_hash
+          @hash
+        end
+      end
+
+      class ToPath < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_path
+          @value
+        end
+      end
+
+      class CustomRange < BlankSlate
+        attr_reader :begin, :end
+
+        def initialize(begin_, end_, exclude_end = false)
+          @begin = begin_
+          @end = end_
+          @exclude_end = exclude_end
+        end
+
+        def exclude_end? = @exclude_end
+      end
+
+      class Each < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def each(&block)
+          @args.each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/rbs/unit_test/spy.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RBS
+  module UnitTest
+    module Spy
+      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 WrapSpy
+        attr_accessor :callback
+        attr_reader :object
+        attr_reader :method_name
+
+        NO_RETURN = Object.new
+
+        def initialize(object:, method_name:)
+          @callback = -> (_) { }
+          @object = object
+          @method_name = method_name
+        end
+
+        def wrapped_object
+          spy = self #: WrapSpy[untyped]
+
+          Class.new(BasicObject) do
+            # @type self: Class
+
+            define_method(:method_missing) do |name, *args, &block|
+              spy.object.__send__(name, *args, &block)
+            end
+
+            define_method(
+              spy.method_name,
+              _ = -> (*args, &block) do
+                return_value = NO_RETURN
+                exception = nil
+                block_calls = [] #: Array[Test::ArgumentsReturn]
+
+                spy_block = if block
+                              Object.new.instance_eval do |fresh|
+                                proc = -> (*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
+
+                                  if block_exn
+                                    block_calls << Test::ArgumentsReturn.exception(
+                                      arguments: block_args,
+                                      exception: block_exn
+                                    )
+                                  else
+                                    block_calls << Test::ArgumentsReturn.return(
+                                      arguments: block_args,
+                                      value: block_return
+                                    )
+                                  end
+
+                                  if block_exn
+                                    raise block_exn
+                                  else
+                                    block_return
+                                  end
+                                end #: Proc
+
+                                proc.ruby2_keywords
+                              end
+                            end
+
+                begin
+                  if spy_block
+                    return_value = spy.object.__send__(spy.method_name, *args) do |*a, **k, &b|
+                      spy_block.call(*a, **k, &b)
+                    end
+                  else
+                    return_value = spy.object.__send__(spy.method_name, *args, &spy_block)
+                  end
+                rescue ::Exception => exn
+                  exception = exn
+                end
+
+                return_value
+
+              ensure
+                call =
+                  case
+                  when exception
+                    Test::ArgumentsReturn.exception(
+                      arguments: args,
+                      exception: exception
+                    )
+                  when ::RBS::UnitTest::Spy::WrapSpy::NO_RETURN != return_value
+                    Test::ArgumentsReturn.return(
+                      arguments: args,
+                      value: return_value
+                    )
+                  else
+                    # break
+                    Test::ArgumentsReturn.break(arguments: args)
+                  end
+                trace = RBS::Test::CallTrace.new(
+                  method_name: spy.method_name,
+                  method_call: call,
+                  block_calls: block_calls,
+                  block_given: block != nil
+                )
+
+                spy.callback.call(trace)
+
+                if exception
+                  spy.object.__send__(:raise, exception)
+                end
+              end.ruby2_keywords
+            )
+          end.allocate()
+        end
+      end
+    end
+  end
+end

data/lib/rbs/unit_test/type_assertions.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+module RBS
+  module UnitTest
+    module TypeAssertions
+      module ClassMethods
+        attr_reader :target
+
+        def library(*libs)
+          if @libs
+            raise "Multiple #library calls are not allowed"
+          end
+
+          @libs = libs
+          @env = nil
+          @target = nil
+        end
+
+        @@env_cache = {} #: Hash[Array[String], RBS::Environment]
+
+        def env
+          @env = @@env_cache[@libs] ||=
+            begin
+              loader = RBS::EnvironmentLoader.new
+              (@libs || []).each do |lib|
+                loader.add(library: lib, version: nil)
+              end
+
+              RBS::Environment.from_loader(loader).resolve_type_names
+            end
+        end
+
+        def builder
+          @builder ||= RBS::DefinitionBuilder.new(env: env)
+        end
+
+        def testing(type_or_string)
+          type = case type_or_string
+                 when String
+                   RBS::Parser.parse_type(type_or_string, variables: []) || raise
+                 else
+                   type_or_string
+                 end
+
+          definition = case type
+                       when RBS::Types::ClassInstance
+                         builder.build_instance(type.name)
+                       when RBS::Types::ClassSingleton
+                         builder.build_singleton(type.name)
+                       else
+                         raise "Test target should be class instance or class singleton: #{type}"
+                       end
+
+          @target = [type, definition] #: [target_type, Definition]
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def env
+        (_ = self.class).env
+      end
+
+      def builder
+        (_ = self.class).builder
+      end
+
+      def targets
+        @targets ||= []
+      end
+
+      def target
+        targets.last || (_ = self.class).target
+      end
+
+      def testing(type_or_string)
+        type = case type_or_string
+               when String
+                 RBS::Parser.parse_type(type_or_string, variables: [])
+               else
+                 type_or_string
+               end
+
+        definition = case type
+                     when RBS::Types::ClassInstance
+                       builder.build_instance(type.name)
+                     when RBS::Types::ClassSingleton
+                       builder.build_singleton(type.name)
+                     else
+                       raise "Test target should be class instance or class singleton: #{type}"
+                     end
+
+        targets.push(
+          [
+            type,  #: target_type
+            definition
+          ]
+        )
+
+        if block_given?
+          begin
+            yield
+          ensure
+            targets.pop
+          end
+        else
+          [type, definition]
+        end
+      end
+
+      def instance_class
+        type, _ = target
+
+        case type
+        when RBS::Types::ClassSingleton, RBS::Types::ClassInstance
+          Object.const_get(type.name.to_s)
+        end
+      end
+
+      def class_class
+        type, _ = target
+
+        case type
+        when RBS::Types::ClassSingleton, RBS::Types::ClassInstance
+          Object.const_get(type.name.to_s).singleton_class
+        end
+      end
+
+      def send_setup(method_type, receiver, method, args, proc)
+        mt =
+          case method_type
+          when String
+            RBS::Parser.parse_method_type(method_type, variables: []) || raise
+          when RBS::MethodType
+            method_type
+          end
+
+        validate_simple_method_type(mt)
+
+        trace = [] #: Array[Test::CallTrace]
+        spy = Spy.wrap(receiver, method)
+        spy.callback = -> (result) { trace << result }
+
+        result = nil #: untyped
+        exception = nil #: Exception?
+        non_jump_exit = true
+
+        begin
+          result = catch do |tag|
+            @break_tag = tag
+            spy.wrapped_object.__send__(method, *args, &proc)
+          ensure
+            @break_tag = nil
+          end
+
+          non_jump_exit = false
+        rescue Exception => exn
+          exception = exn
+        ensure
+          if non_jump_exit && !exception
+            raise "`break` nor `return` from blocks given to `assert_send_type` are prohibited. Use `#break_from_block` instead."
+          end
+        end
+
+        last_trace = trace.last or raise "empty trace"
+
+        yield(mt, last_trace, result, exception)
+      end
+
+      ruby2_keywords def assert_send_type(method_type, receiver, method, *args, &block)
+        send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
+          typecheck = RBS::Test::TypeCheck.new(
+            self_class: receiver.class,
+            builder: builder,
+            sample_size: 100,
+            unchecked_classes: [],
+            instance_class: instance_class,
+            class_class: class_class
+          )
+          errors = typecheck.method_call(method, method_type, trace, errors: [])
+
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
+
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.annotations) }
+          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+
+          raise exception if exception
+
+          result
+        end
+      end
+
+      ruby2_keywords def refute_send_type(method_type, receiver, method, *args, &block)
+        send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
+          method_type = method_type.update(
+            block:
+              if method_type.block
+                RBS::Types::Block.new(
+                  type: method_type.block.type.with_return_type(RBS::Types::Bases::Any.new(location: nil)),
+                  required: method_type.block.required,
+                  self_type: nil
+                )
+              end,
+            type: method_type.type.with_return_type(RBS::Types::Bases::Any.new(location: nil))
+          )
+
+          typecheck = RBS::Test::TypeCheck.new(
+            self_class: receiver.class,
+            instance_class: instance_class,
+            class_class: class_class,
+            builder: builder,
+            sample_size: 100,
+            unchecked_classes: []
+          )
+          errors = typecheck.method_call(method, method_type, trace, errors: [])
+
+          assert_operator exception, :is_a?, ::Exception
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
+
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.annotations) }
+          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+
+          result
+        end
+      end
+
+      def method_defs(method)
+        type, definition = target
+
+        case type
+        when Types::ClassInstance
+          subst = RBS::Substitution.build(definition.type_params, type.args)
+          definition.methods[method].defs.map do |type_def|
+            type_def.update(
+              type: type_def.type.sub(subst)
+            )
+          end
+        when Types::ClassSingleton
+          definition.methods[method].defs
+        else
+          raise
+        end
+      end
+
+      def method_types(method)
+        method_defs(method).map(&:type)
+      end
+
+      def allows_error(*errors)
+        yield
+      rescue *errors => exn
+        notify "Error allowed: #{exn.inspect}"
+      end
+
+      def assert_const_type(type, constant_name)
+        constant = Object.const_get(constant_name)
+
+        typecheck = RBS::Test::TypeCheck.new(
+          self_class: constant.class,
+          instance_class: instance_class,
+          class_class: class_class,
+          builder: builder,
+          sample_size: 100,
+          unchecked_classes: []
+        )
+
+        value_type =
+          case type
+          when String
+            RBS::Parser.parse_type(type, variables: []) || raise
+          else
+            type
+          end
+
+        assert typecheck.value(constant, value_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with given type `#{value_type}`"
+
+        type_name = TypeName.parse(constant_name).absolute!
+        definition = env.constant_entry(type_name)
+        assert definition, "Cannot find RBS type definition of `#{constant_name}`"
+
+        case definition
+        when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+          definition_type = RBS::Types::ClassSingleton.new(name: type_name, location: nil)
+        when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+          type_name = env.normalize_type_name!(type_name)
+          definition_type = RBS::Types::ClassSingleton.new(name: type_name, location: nil)
+        when RBS::Environment::ConstantEntry
+          definition_type = definition.decl.type
+        end
+
+        assert definition_type, "Cannot find RBS entry for `#{constant_name}`"
+        definition_type or raise
+        assert typecheck.value(constant, definition_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with RBS type definition `#{definition_type}`"
+      end
+
+      def assert_type(type, value)
+        typecheck = RBS::Test::TypeCheck.new(
+          self_class: value.class,
+          instance_class: _ = "No `instance` class allowed",
+          class_class: _ = "No `class` class allowed",
+          builder: builder,
+          sample_size: 100,
+          unchecked_classes: []
+        )
+
+        type =
+          case type
+          when String
+            RBS::Parser.parse_type(type, variables: []) or raise
+          else
+            type
+          end
+
+        assert typecheck.value(value, type), "`#{value.inspect}` must be compatible with given type `#{type}`"
+      end
+
+      def allow_non_simple_method_type()
+        begin
+          @allows_non_simple_method_type = true
+          yield
+        rescue
+          @allows_non_simple_method_type = false
+        end
+      end
+
+      def validate_simple_method_type(type)
+        return if @allows_non_simple_method_type
+
+        refute_predicate type, :has_self_type?, "`self` types is prohibited in method type: `#{type}`"
+        refute_predicate type, :has_classish_type?, "`instance` and `class` types is prohibited in method type: `#{type}`"
+        refute_predicate type, :with_nonreturn_void?, "`void` is only allowed at return type or generics parameters: `#{type}`"
+      end
+
+      def break_from_block(value = nil)
+        raise "Cannot break without `@break_tag`" unless @break_tag
+        throw @break_tag, value
+      end
+
+      def pass(message = nil)
+        assert true, message
+      end
+    end
+  end
+end