rbs-relaxed 3.9.0.1

data/sig/unit_test/convertibles.rbs

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

data/sig/unit_test/spy.rbs

@@ -0,0 +1,30 @@
+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]
+        NO_RETURN: Object
+
+        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

data/sig/unit_test/type_assertions.rbs

@@ -0,0 +1,196 @@
+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_defs: (Symbol) -> Array[Definition::Method::TypeDef]
+
+      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

data/sig/unit_test/with_aliases.rbs

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

data/sig/use_map.rbs

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

data/sig/util.rbs

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

data/sig/validator.rbs

@@ -0,0 +1,63 @@
+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
+
+    # Validates instance/class-instance/class variables.
+    #
+    def validate_variable: (AST::Members::Var) -> 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