rbs 3.3.2 → 3.4.0

data/sig/test.rbs

@@ -0,0 +1,82 @@
+module RBS
+  module Test
+    # Object#class
+    CLASS: UnboundMethod
+
+    # Module#define_method
+    DEFINE_METHOD: UnboundMethod
+
+    # Kernel#inspect
+    INSPECT: UnboundMethod
+
+    # BasicObject#instance_eval
+    INSTANCE_EVAL: UnboundMethod
+
+    # BasicObject#instance_exec
+    INSTANCE_EXEC: UnboundMethod
+
+    # Kernel#is_a?
+    IS_AP: UnboundMethod
+
+    # Kernel#method
+    METHOD: UnboundMethod
+
+    # Kernel#methods
+    METHODS: UnboundMethod
+
+    # Kernel#pp
+    PP: UnboundMethod
+
+    # Kernel#singleton_class
+    SINGLETON_CLASS: UnboundMethod
+
+    # Kernel#respond_to?
+    RESPOND_TOP: UnboundMethod
+
+    class ArgumentsReturn
+      type exit_type = :return | :exception | :break
+
+      attr_reader arguments: Array[untyped]
+
+      attr_reader exit_value: untyped
+
+      attr_reader exit_type: exit_type
+
+      def initialize: (arguments: Array[untyped], exit_value: untyped, exit_type: exit_type) -> void
+
+      def self.return: (arguments: Array[untyped], value: untyped) -> ArgumentsReturn
+
+      def self.exception: (arguments: Array[untyped], exception: untyped) -> ArgumentsReturn
+
+      def self.break: (arguments: Array[untyped]) -> ArgumentsReturn
+
+      def return_value: () -> untyped
+
+      def exception: () -> untyped
+
+      def return?: () -> bool
+
+      def exception?: () -> bool
+
+      def break?: () -> bool
+    end
+
+    class CallTrace
+      attr_reader method_name: Symbol
+
+      attr_reader method_call: ArgumentsReturn
+
+      attr_reader block_calls: Array[ArgumentsReturn]
+
+      attr_reader block_given: bool
+
+      def initialize: (method_name: Symbol, method_call: ArgumentsReturn, block_calls: Array[ArgumentsReturn], block_given: bool) -> void
+    end
+
+    attr_accessor self.suffix: String
+
+    def self.reset_suffix: () -> String
+
+    def self.call: (untyped receiver, UnboundMethod, *untyped) ?{ () -> void } -> void
+  end
+end

data/sig/types.rbs

@@ -53,7 +53,7 @@ module RBS
       #
       # * The function return type is a return position (`() -> void`)
       # * Generic parameter is a return position (`Enumerator[Integer, void]`)
-      # 
+      #
       def with_nonreturn_void?: () -> bool
     end
 
@@ -497,6 +497,11 @@ module RBS
       include NoTypeName
 
       attr_reader location: loc?
+
+      TABLE: Hash[String, String]
+
+      # Unescape string type body
+      def self.unescape_string: (String, bool is_double_quote) -> String
     end
   end
 end

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,28 @@
+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

data/sig/unit_test/type_assertions.rbs

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

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