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

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

@@ -1,154 +0,0 @@
-module RBS
-  module UnitTest
-    module Convertibles
-      # An object that doesn't have methods excepts `__send__` and `__id__`
-      #
-      # Other methods are `undef`ed.
-      #
-      class BlankSlate < BasicObject
-        # Add Object methods to `self`
-        #
-        def __with_object_methods: (*Symbol methods) -> self
-      end
-
-      # An object with `#to_io` method
-      class ToIO < BlankSlate
-        @io: untyped
-
-        def initialize: (?untyped io) -> void
-
-        def to_io: () -> untyped
-      end
-
-      # An object with `#to_i` method
-      class ToI < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_i: () -> untyped
-      end
-
-      # An object with `#to_int` method
-      class ToInt < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_int: () -> untyped
-      end
-
-      # An object with `#to_f` method
-      class ToF < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_f: () -> untyped
-      end
-
-      # An object with `#to_r` method
-      class ToR < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_r: () -> untyped
-      end
-
-      # An object with `#to_c` method
-      class ToC < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_c: () -> untyped
-      end
-
-      # An object with `#to_str` method
-      class ToStr < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_str: () -> untyped
-      end
-
-      # An object with `#to_s` method
-      class ToS < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_s: () -> untyped
-      end
-
-      # An object with `#to_sym` method
-      class ToSym < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_sym: () -> untyped
-      end
-
-      # An object with `#to_a` method
-      class ToA < BlankSlate
-        @args: untyped
-
-        def initialize: (*untyped args) -> void
-
-        def to_a: () -> Array[untyped]
-      end
-
-      # An object with `#to_ary` method
-      class ToArray < BlankSlate
-        @args: untyped
-
-        def initialize: (*untyped args) -> void
-
-        def to_ary: () -> Array[untyped]
-      end
-
-      # An object with `#to_hash` method
-      class ToHash < BlankSlate
-        @hash: untyped
-
-        def initialize: (?::Hash[untyped, untyped] hash) -> void
-
-        def to_hash: () -> Hash[untyped, untyped]
-      end
-
-      # An object with `#to_path` method
-      class ToPath < BlankSlate
-        @value: untyped
-
-        def initialize: (?untyped value) -> void
-
-        def to_path: () -> untyped
-      end
-
-      # An object with `#begin`, `#end`, and `#exclude_end`
-      class CustomRange < BlankSlate
-        @exclude_end: untyped
-
-        attr_reader begin: untyped
-
-        attr_reader end: untyped
-
-        def initialize: (untyped begin_, untyped end_, ?untyped exclude_end) -> void
-
-        def exclude_end?: () -> untyped
-      end
-
-      # An object with `#each` method
-      class Each < BlankSlate
-        @args: Array[untyped]
-
-        def initialize: (*untyped args) -> void
-
-        def each: () { (untyped) -> void } -> untyped
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module RBS
-  module UnitTest
-    module Spy
-      def self.wrap: [T] (untyped object, Symbol method_name) -> WrapSpy[T]
-                   | [T, S] (untyped object, Symbol method_name) { (WrapSpy[T], T) -> S } -> S
-
-      class WrapSpy[T]
-        attr_accessor callback: ^(Test::CallTrace) -> void
-
-        attr_reader object: T
-
-        attr_reader method_name: Symbol
-
-        def initialize: (object: T, method_name: Symbol) -> void
-
-        def wrapped_object: () -> untyped
-      end
-    end
-  end
-end
-
-class Proc
-  def ruby2_keywords: () -> self
-end
-
-class Module
-  def ruby2_keywords: (*Symbol) -> void
-end

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

@@ -1,194 +0,0 @@
-module RBS
-  module UnitTest
-    # TypeAssertions provides assertions to test RBS type definitions in unit test
-    #
-    # ```ruby
-    # class FooInstanceTest < Test::Unit::TestCase
-    #   include RBS::UnitTest::TypeAssertions
-    #
-    #   testing "::Foo"
-    #
-    #   def test_foo
-    #     assert_send_type(
-    #       "(String) -> Integer",
-    #       Foo.new, :foo, "hello"
-    #     )
-    #   end
-    # end
-    # ```
-    #
-    # The module provides four assertions:
-    #
-    # * `assert_send_type` to confirm if a method call has the expected method type
-    # * `refute_send_type` to confirm if a method call doesn't have the method type
-    # * `assert_const_type` to confirm if a constant has an expected type
-    # * `assert_type` to confirm a Ruby value has a RBS type
-    #
-    # See `.testing` and `.library` methods to set up RBS type testing.
-    #
-    module TypeAssertions : _BaseAssertions
-      type target_type = Types::ClassInstance | Types::ClassSingleton
-
-      interface _BaseAssertions
-        def assert: (untyped, ?String?) -> void
-
-        def refute: (untyped, ?String?) -> void
-
-        def assert_empty: (untyped, ?String?) -> void
-
-        def assert_operator: (untyped, Symbol, *untyped) -> void
-
-        def notify: (untyped) -> void
-
-        def assert_predicate: (untyped, Symbol, ?String?) -> void
-
-        def refute_predicate: (untyped, Symbol, ?String?) -> void
-      end
-
-      module ClassMethods
-        attr_reader target: [target_type, Definition]?
-
-        @libs: Array[String]
-
-        @env: Environment?
-
-        @@env_cache: Hash[Array[String], Environment]
-
-        # `testing` is to tell the framework which class is being tested
-        #
-        # ```ruby
-        # testing "::String"
-        # testing "::Array[Integer]"
-        #
-        # testing "singleton(::Integer)"
-        # ```
-        #
-        def testing: (String | target_type) -> void
-
-        # `library` is to load RBS type definition of dependencies
-        #
-        # The test or implementation already `require` dependencies, but the RBS type definition of the dependencies are also required for testing.
-        #
-        # ```ruby
-        # library "pathname", "securerandom"
-        # ```
-        #
-        def library: (*String) -> void
-
-        def env: () -> Environment
-
-        @builder: DefinitionBuilder
-
-        def builder: () -> DefinitionBuilder
-      end
-
-      def self.included: (Module) -> void
-
-      def env: () -> Environment
-
-      def builder: () -> DefinitionBuilder
-
-      @targets: Array[[target_type, Definition]]
-
-      def targets: () -> Array[[target_type, Definition]]
-
-      def target: () -> [target_type, Definition]
-
-      def testing: (String | target_type) ?{ () -> void } -> void
-
-      # The class object that is associated to the `instance` type of the testing type
-      #
-      def instance_class: () -> Class
-
-      # The singleton class object that is associated to the `class` type of the testing type
-      #
-      def class_class: () -> Class
-
-      def method_types: (Symbol) -> Array[MethodType]
-
-      def allows_error: (*Exception) { () -> void } -> void
-
-      # Calls a method `method_name` and validates if it's compatible with RBS type definition
-      #
-      # 1. It calls `method_name` with `receiver` passing `args` and given block,
-      # 2. Validates if it's compatible with given `method_type`, and
-      # 3. Validates if it's also compatible with one of the overloads defined in RBS type definition
-      #
-      # ```ruby
-      # assert_send_type(
-      #   "(::Integer) -> ::Integer",
-      #   [], :sum, 8
-      # )
-      # ```
-      #
-      # To test methods that takes a block, pass a block to `assert_send_type`.
-      # We recommend using `&proc { ... }` syntax for textual representation and prevent from using `break` from the block.
-      #
-      # ```ruby
-      # assert_send_type(
-      #   "() { () -> void } -> void",
-      #   self, :loop, &proc { break_from_block }
-      # )
-      # ```
-      #
-      # Exiting from the block using `break` and `return` skips assertions.
-      # Use `break_from_block` instead.
-      #
-      # `method_type` must be _simple_.
-      # It raises an exception if it's not _simple_.
-      # When you really need _non-simple_ `method_type`, wrap the calls inside `allow_non_simple_method_type`.
-      # See `docs/stdlib.md` for the details.
-      #
-      def assert_send_type: (String | MethodType method_type, untyped receiver, Symbol method_name, *untyped args) ?{ () -> untyped } -> void
-
-      # Calls a method `method_name` and validates if it's **not** compatible with RBS type definition
-      #
-      # 1. It calls `method_name` with `receiver` passing `args` and given block,
-      # 2. Validates if it's compatible with given `method_type`, and
-      # 3. Validates if it's not compatible with **none** of the overloads defined in RBS type definition
-      #
-      # See `assert_send_type` for the details.
-      #
-      def refute_send_type: (String | MethodType method_type, untyped receiver, Symbol method_name, *untyped args) ?{ () -> untyped } -> void
-
-      # Asserts if the constant `constant_name` has `constant_type`, and the RBS definition has compatible type
-      #
-      # ```ruby
-      # assert_const_type("Array[String]", "::Foo::Bar")
-      # ```
-      #
-      # The assertion above succeeds if `::Foo::Bar` is `["foo"]` and RBS contains `::Foo::Bar: [untyped]`.
-      # It fails if `::Foo::Bar` is `[2]`, or the RBS definition is `::Foo::Bar: String`.
-      #
-      def assert_const_type: (String | Types::t constant_type, String constant_name) -> void
-
-      # Asserts if given `value` has a type of `value_type`
-      #
-      def assert_type: (String | Types::t value_type, untyped value) -> void
-
-      # Allow non _simple-type_ method types given to `assert_send_type` and `refute_send_type`
-      #
-      # ```ruby
-      # allow_non_simple_method_type do
-      #   assert_send_type("() -> self", ...)
-      # end
-      # ```
-      #
-      def allow_non_simple_method_type: () { () -> void } -> void
-
-      @allows_non_simple_method_type: boolish
-
-      def validate_simple_method_type: (MethodType) -> void
-
-      # Break from `assert_send_type` or `refute_send_type`
-      #
-      def break_from_block: (?untyped value) -> void
-
-      @break_tag: untyped
-
-      def send_setup: [T] (String | RBS::MethodType method_type, untyped receiver, Symbol method_name, Array[untyped] args, Proc?) { (RBS::MethodType, Test::CallTrace, untyped, Exception?) -> T } -> T
-
-      def pass: (?String? message) -> void
-    end
-  end
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/unit_test/with_aliases.rbs

@@ -1,136 +0,0 @@
-module RBS
-  module UnitTest
-    # WithAliases module provides `with_***` methods that helps writing tests which passes convertible objects
-    #
-    # ```ruby
-    # include WithAliases
-    #
-    # with_int do |i|
-    #   # Yields Integer and RBS::UnitTest::Convertibles::ToInt
-    # end
-    #
-    # with_string.and_nil do |s|
-    #   # Yields String, RBS::UnitTest::Convertibles::ToStr, and nil
-    # end
-    # ```
-    #
-    module WithAliases
-      include Convertibles
-
-      class WithEnum[T]
-        @enum: _Each[T]
-
-        include Enumerable[T]
-
-        def initialize: (_Each[T] enum) -> void
-
-        def each: () { (T) -> void } -> void
-
-        # Yield `nil` in addition to original `enum` elements
-        #
-        # ```ruby
-        # e = WithEnum.new([1, 2])
-        # e.and_nil do |i|
-        #   pp i     # => 1, 2, and nil
-        # end
-        # ```
-        #
-        def and_nil: () { (T?) -> void } -> void
-                   | () -> WithEnum[T?]
-
-        # Skip yielding objects in `cases`
-        #
-        # ```ruby
-        # e = WithEnum.new([1, 2, 3])
-        # e.but(2) do |i|
-        #   pp i     # => 1 and 3
-        # end
-        # ```
-        #
-        def but: (*T cases) { (T) -> void } -> void
-               | (*T cases) -> WithEnum[T]
-
-        # Yield objects in `args` in addition to original `enum` elements
-        #
-        # ```ruby
-        # e = WithEnum.new([1, 2])
-        # e.and(3) do |i|
-        #   pp i     # => 1, 2, and 3
-        # end
-        # ```
-        #
-        def and: [S] (*S args) { (T | S) -> void } -> void
-               | [S] (*S args) -> WithEnum[T | S]
-      end
-
-      # Yields `args` objects
-      #
-      def with: (*untyped args) -> void
-              | (*untyped args) { (untyped) -> void } -> void
-
-      # Yields `::int` objects
-      #
-      def with_int: (?Integer value) { (int) -> void } -> void
-                  | (?Integer value) -> WithEnum[int]
-
-      # Yields `::float` objects
-      #
-      def with_float: (?Float value) { (float) -> void } -> void
-                    | (?Float value) -> WithEnum[float]
-
-      # Yields `::string` objects
-      #
-      def with_string: (?String value) { (string) -> void } -> void
-                     | (?String value) -> WithEnum[string]
-
-      # Yields `::array` objects
-      #
-      def with_array: [T] (*T elements) { (array[T]) -> void } -> void
-                    | [T] (*T elements) -> WithEnum[array[T]]
-
-      # Yields `::hash` objects
-      #
-      def with_hash: [K, V] (?Hash[K, V] hash) { (hash[K, V]) -> void } -> void
-                   | [K, V] (?Hash[K, V] hash) -> WithEnum[hash[K, V]]
-
-      # Yields `::io` objects
-      #
-      def with_io: (?untyped io) { (io) -> void } -> void
-                 | (?untyped io) -> WithEnum[io]
-
-      # Yields `::path` objects
-      #
-      def with_path: (?String path) { (path) -> void } -> void
-                   | (?String path) -> WithEnum[path]
-
-      # Yields `::encoding` objects
-      #
-      def with_encoding: (?untyped encoding) { (encoding) -> void } -> void
-                       | (?untyped encoding) -> WithEnum[encoding]
-
-      # Yields `::interned` objects
-      #
-      def with_interned: (?Symbol value) { (interned) -> void } -> void
-                       | (?Symbol value) -> WithEnum[interned]
-
-      # Yields `::bool` objects
-      #
-      def with_bool: () { (bool) -> void } -> void
-                   | () -> WithEnum[bool]
-
-      # Yields `::boolish` objects
-      #
-      def with_boolish: () { (boolish) -> void } -> void
-                      | () -> WithEnum[boolish]
-
-      # Yields `::untyped` objects
-      #
-      def with_untyped: () { (untyped) -> void } -> void
-                      | () -> WithEnum[untyped]
-
-      # Yields `::range` objects
-      #
-      def with_range: (WithEnum[untyped] start, WithEnum[untyped] stop, ?bool exclude_end) { (range[untyped]) -> void } -> void
-    end
-  end
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/use_map.rbs

@@ -1,35 +0,0 @@
-module RBS
-  class Environment
-    # ```rb
-    # map = UseMap.build(environment)
-    #
-    # map.resolve?(TypeName.parse("TN"))   # => nil or resolved type name
-    # ```
-    #
-    class UseMap
-      class Table
-        attr_reader known_types: Set[TypeName]
-
-        attr_reader children: Hash[Namespace, Set[TypeName]]
-
-        def initialize: () -> void
-
-        def compute_children: () -> self
-      end
-
-      attr_reader use_dirs: Array[AST::Directives::Use]
-
-      @map: Hash[Symbol, TypeName]
-
-      @table: Table
-
-      def initialize: (table: Table) -> void
-
-      def resolve?: (TypeName) -> TypeName?
-
-      def resolve: (TypeName) -> TypeName
-
-      def build_map: (AST::Directives::Use::clause) -> self
-    end
-  end
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/util.rbs

@@ -1,9 +0,0 @@
-module RBS
-  interface _HashEqual
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/validator.rbs

@@ -1,59 +0,0 @@
-module RBS
-  class Validator
-    attr_reader env: Environment
-
-    attr_reader resolver: Resolver::TypeNameResolver?
-
-    attr_reader definition_builder: DefinitionBuilder
-
-    attr_reader type_alias_dependency: TypeAliasDependency
-
-    attr_reader type_alias_regularity: TypeAliasRegularity
-
-    def initialize: (env: Environment, ?resolver: Resolver::TypeNameResolver?) -> void
-
-    # Validates the presence of type names and type application arity match.
-    #
-    def validate_type: (Types::t, context: Resolver::context) -> void
-
-    # Validates type alias definition:
-    #
-    # - There is no circular definition between aliases
-    # - The type alias is _regular_
-    # - The generics type parameter variance annotation is consistent with respect to their usage
-    # - There is no circular dependencies between the generics type parameter bounds
-    #
-    # It yields the rhs type if block is given, so that you can validate the rhs type.
-    #
-    def validate_type_alias: (entry: Environment::TypeAliasEntry) ?{ (Types::t rhs_type) -> void } -> void
-
-    # Validates the type parameters in generic methods.
-    #
-    def validate_method_definition: (AST::Members::MethodDefinition, type_name: TypeName) -> void
-
-    # Validates the type parameters if there is no circular dependencies between the bounds.
-    #
-    # ```rbs
-    # [X, Y]                      # OK
-    # [X, Y < _Foo[X]]            # OK
-    # [X < _Foo[Y], Y]            # OK
-    # [X < _Foo[Y], Y < _Foo[X]]  # Error
-    # ```
-    #
-    def validate_type_params: (Array[AST::TypeParam] params, type_name: TypeName, ?method_name: Symbol?, location: Location[untyped, untyped]?) -> void
-
-    # Validates class alias declaration
-    #
-    # - The right hand side can be normalized
-    # - No mixing alias declaration between class and modules
-    #
-    def validate_class_alias: (entry: Environment::ClassAliasEntry | Environment::ModuleAliasEntry) -> void
-
-    private
-
-    # Resolves relative type names to absolute type names in given context.
-    # Yields the type when the type name resolution using `#resolver` fails.
-    #
-    def absolute_type: (Types::t, context: Resolver::context) ?{ (Types::t) -> TypeName } -> Types::t
-  end
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/variance_calculator.rbs

@@ -1,87 +0,0 @@
-module RBS
-  # Calculate the use variances of type variables in declaration.
-  #
-  # ```rb
-  # calculator = VarianceCalculator.new(builder: builder)
-  #
-  # # Calculates variances in a method type
-  # result = calculator.in_method_type(method_type: method_type, variables: variables)
-  #
-  # # Calculates variances in a inheritance/mixin/...
-  # result = calculator.in_inherit(name: name, args: args, variables: variables)
-  #
-  # # Calculates variances in a type alias
-  # result = calculator.in_type_alias(name: name, args: args, variables: variables)
-  # ```
-  #
-  # See `RBS::VarianceCalculator::Result` for information recorded in the `Result` object.
-  #
-  class VarianceCalculator
-    type variance = :unused | :covariant | :contravariant | :invariant
-
-    # Result contains the set of type variables and it's variance in a occurrence.
-    #
-    # ```rb
-    # # Enumerates recorded type variables
-    # result.each do |name, variance|
-    #   # name is the name of a type variable
-    #   # variance is one of :unused | :covariant | :contravariant | :invariant
-    # end
-    # ```
-    #
-    # You can test with `compatible?` method if the type variable occurrences are compatible with specified (annotated) variance.
-    #
-    # ```rb
-    # # When T is declared as `out T`
-    # result.compatible?(:T, with_annotation: :covariant)
-    #
-    # # When T is declared as `in T`
-    # result.compatible?(:T, with_annotation: :contravariant)
-    #
-    # # When T is declared as `T`
-    # result.compatible?(:T, with_annotation: :invariant)
-    # ```
-    #
-    class Result
-      attr_reader result: Hash[Symbol, variance]
-
-      def initialize: (variables: Array[Symbol]) -> void
-
-      def covariant: (Symbol) -> void
-
-      def contravariant: (Symbol) -> void
-
-      def invariant: (Symbol) -> void
-
-      def each: () { ([Symbol, variance]) -> void } -> void
-
-      def include?: (Symbol) -> bool
-
-      def compatible?: (Symbol, with_annotation: variance) -> bool
-
-      def incompatible?: (Array[AST::TypeParam]) -> Set[Symbol]?
-    end
-
-    attr_reader builder: DefinitionBuilder
-
-    def initialize: (builder: DefinitionBuilder) -> void
-
-    def env: () -> Environment
-
-    def in_method_type: (method_type: MethodType, variables: Array[Symbol]) -> Result
-
-    def in_inherit: (name: TypeName, args: Array[Types::t], variables: Array[Symbol]) -> Result
-
-    # The type name must be normalized
-    #
-    def in_type_alias: (name: TypeName) -> Result
-
-    private
-
-    def type: (Types::t, result: Result, context: variance) -> void
-
-    def function: (Types::function, result: Result, context: variance) -> void
-
-    def negate: (variance) -> variance
-  end
-end