rbs 2.8.4 → 3.8.1

data/lib/rbs/unit_test/spy.rb

@@ -0,0 +1,136 @@
+# 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
+
+        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 = nil
+                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 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,341 @@
+# 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
+
+        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_types = method_types(method)
+          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
+          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_types.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_types = method_types(method)
+          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
+          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+
+          result
+        end
+      end
+
+      def method_types(method)
+        type, definition = target
+
+        case type
+        when Types::ClassInstance
+          subst = RBS::Substitution.build(definition.type_params, type.args)
+          definition.methods[method].method_types.map do |method_type|
+            method_type.sub(subst)
+          end
+        when Types::ClassSingleton
+          definition.methods[method].method_types
+        else
+          raise
+        end
+      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

data/lib/rbs/unit_test/with_aliases.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RBS
+  module UnitTest
+    module WithAliases
+      include Convertibles
+
+      class WithEnum
+        include Enumerable
+
+        def initialize(enum) = @enum = enum
+
+        def each(&block) = @enum.each(&block)
+
+        def and_nil(&block)
+          self.and(nil, &_ = block)
+        end
+
+        def but(*cases, &block)
+          return WithEnum.new to_enum(__method__ || raise, *cases) unless block
+
+          each do |arg|
+            yield arg unless cases.any? { (_ = _1) === arg }
+          end
+        end
+
+        def and(*args, &block)
+          return WithEnum.new to_enum(__method__ || raise, *args) unless block
+
+          each(&block)
+          args.each do |arg|
+            if WithEnum === arg # use `===` as `arg` might not have `.is_a?` on it
+              arg.each(&block)
+            else
+              block.call(_ = arg)
+            end
+          end
+        end
+      end
+
+      def with(*args, &block)
+        return WithEnum.new to_enum(__method__ || raise, *args) unless block
+        args.each(&block)
+      end
+
+      def with_int(value = 3, &block)
+        return WithEnum.new to_enum(__method__ || raise, value) unless block
+        yield value
+        yield ToInt.new(value)
+      end
+
+      def with_float(value = 0.1)
+        return WithEnum.new to_enum(__method__ || raise, value) unless block_given?
+        yield value
+        yield ToF.new(value)
+      end
+
+      def with_string(value = '')
+        return WithEnum.new to_enum(__method__ || raise, value) unless block_given?
+        yield value
+        yield ToStr.new(value)
+      end
+
+      def with_array(*elements)
+        return WithEnum.new to_enum(__method__ || raise, *elements) unless block_given?
+
+        yield _ = elements
+        yield ToArray.new(*elements)
+      end
+
+      def with_hash(hash = {})
+        return WithEnum.new to_enum(__method__ || raise, hash) unless block_given?
+
+        yield _ = hash
+        yield ToHash.new(hash)
+      end
+
+      def with_io(io = $stdout)
+        return WithEnum.new to_enum(__method__ || raise, io) unless block_given?
+        yield io
+        yield ToIO.new(io)
+      end
+
+      def with_path(path = "/tmp/foo.txt", &block)
+        return WithEnum.new to_enum(__method__ || raise, path) unless block
+
+        with_string(path, &block)
+        block.call ToPath.new(path)
+      end
+
+      def with_encoding(encoding = Encoding::UTF_8, &block)
+        return WithEnum.new to_enum(__method__ || raise, encoding) unless block
+
+        block.call encoding
+        with_string(encoding.to_s, &block)
+      end
+
+      def with_interned(value = :&, &block)
+        return WithEnum.new to_enum(__method__ || raise, value) unless block
+
+        with_string(value.to_s, &block)
+        block.call value.to_sym
+      end
+
+      def with_bool(&block)
+        return WithEnum.new to_enum(__method__ || raise) unless block
+        yield true
+        yield false
+      end
+
+      def with_boolish(&block)
+        return WithEnum.new to_enum(__method__ || raise) unless block
+        with_bool(&block)
+        [nil, 1, Object.new, BlankSlate.new, "hello, world!"].each(&block)
+      end
+
+      alias with_untyped with_boolish
+
+      def with_range(start, stop, exclude_end = false)
+        # If you need fixed starting and stopping points, you can just do `with_range with(1), with(2)`.
+        raise ArgumentError, '`start` must be from a `with` method' unless start.is_a? WithEnum
+        raise ArgumentError, '`stop` must be from a `with` method' unless stop.is_a? WithEnum
+
+        start.each do |lower|
+          stop.each do |upper|
+            yield CustomRange.new(lower, upper, exclude_end)
+
+            # `Range` requires `begin <=> end` to return non-nil, but doesn't actually
+            # end up using the return value of it. This is to add that in when needed.
+            def lower.<=>(rhs) = :not_nil unless defined? lower.<=>
+
+            # If `lower <=> rhs` is defined but nil, then that means we're going to be constructing
+            # an illegal range (eg `3..ToInt.new(4)`). So, we need to skip yielding an invalid range
+            # in that case.
+            next if defined?(lower.<=>) && nil == (lower <=> upper)
+
+            yield Range.new(lower, upper, exclude_end)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/unit_test.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require "rbs/test"
+require "rbs/unit_test/spy"
+require "rbs/unit_test/type_assertions"
+require "rbs/unit_test/convertibles"
+require "rbs/unit_test/with_aliases"