@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-4

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/unit_test/convertibles.rb

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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/unit_test/spy.rb

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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/unit_test/type_assertions.rb

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