rbs 0.12.2 → 0.16.0

data/{stdlib/builtin → core}/basic_object.rbs

@@ -1,108 +1,108 @@
 # BasicObject is the parent class of all classes in Ruby.  It's an explicit
 # blank class.
-# 
+#
 # BasicObject can be used for creating object hierarchies independent of Ruby's
 # object hierarchy, proxy objects like the Delegator class, or other uses where
 # namespace pollution from Ruby's methods and classes must be avoided.
-# 
+#
 # To avoid polluting BasicObject for other users an appropriately named subclass
 # of BasicObject should be created instead of directly modifying BasicObject:
-# 
+#
 #     class MyObjectSystem < BasicObject
 #     end
-# 
+#
 # BasicObject does not include Kernel (for methods like `puts`) and BasicObject
 # is outside of the namespace of the standard library so common classes will not
 # be found without using a full class path.
-# 
+#
 # A variety of strategies can be used to provide useful portions of the standard
 # library to subclasses of BasicObject.  A subclass could `include Kernel` to
 # obtain `puts`, `exit`, etc.  A custom Kernel-like module could be created and
 # included or delegation can be used via #method_missing:
-# 
+#
 #     class MyObjectSystem < BasicObject
 #       DELEGATE = [:puts, :p]
-# 
+#
 #       def method_missing(name, *args, &block)
 #         super unless DELEGATE.include? name
 #         ::Kernel.send(name, *args, &block)
 #       end
-# 
+#
 #       def respond_to_missing?(name, include_private = false)
 #         DELEGATE.include?(name) or super
 #       end
 #     end
-# 
+#
 # Access to classes and modules from the Ruby standard library can be obtained
 # in a BasicObject subclass by referencing the desired constant from the root
 # like `::File` or `::Enumerator`. Like #method_missing, #const_missing can be
 # used to delegate constant lookup to `Object`:
-# 
+#
 #     class MyObjectSystem < BasicObject
 #       def self.const_missing(name)
 #         ::Object.const_get(name)
 #       end
 #     end
-# 
+#
 class BasicObject
   # Boolean negate.
-  # 
+  #
   def !: () -> bool
 
   # Returns true if two objects are not-equal, otherwise false.
-  # 
+  #
   def !=: (untyped other) -> bool
 
   # Equality --- At the `Object` level, `==` returns `true` only if `obj` and
   # `other` are the same object. Typically, this method is overridden in
   # descendant classes to provide class-specific meaning.
-  # 
+  #
   # Unlike `==`, the `equal?` method should never be overridden by subclasses as
   # it is used to determine object identity (that is, `a.equal?(b)` if and only if
   # `a` is the same object as `b`):
-  # 
+  #
   #     obj = "a"
   #     other = obj.dup
-  # 
+  #
   #     obj == other      #=> true
   #     obj.equal? other  #=> false
   #     obj.equal? obj    #=> true
-  # 
+  #
   # The `eql?` method returns `true` if `obj` and `other` refer to the same hash
   # key.  This is used by Hash to test members for equality.  For objects of class
   # `Object`, `eql?` is synonymous with `==`.  Subclasses normally continue this
   # tradition by aliasing `eql?` to their overridden `==` method, but there are
   # exceptions.  `Numeric` types, for example, perform type conversion across
   # `==`, but not across `eql?`, so:
-  # 
+  #
   #     1 == 1.0     #=> true
   #     1.eql? 1.0   #=> false
-  # 
+  #
   def ==: (untyped other) -> bool
 
   # Returns an integer identifier for `obj`.
-  # 
+  #
   # The same number will be returned on all calls to `object_id` for a given
   # object, and no two active objects will share an id.
-  # 
+  #
   # Note: that some objects of builtin classes are reused for optimization. This
   # is the case for immediate values and frozen string literals.
-  # 
+  #
   # Immediate values are not passed by reference but are passed by value: `nil`,
   # `true`, `false`, Fixnums, Symbols, and some Floats.
-  # 
+  #
   #     Object.new.object_id  == Object.new.object_id  # => false
   #     (21 * 2).object_id    == (21 * 2).object_id    # => true
   #     "hello".object_id     == "hello".object_id     # => false
   #     "hi".freeze.object_id == "hi".freeze.object_id # => true
-  # 
+  #
   def __id__: () -> Integer
 
   # Invokes the method identified by *symbol*, passing it any arguments specified.
   # You can use `__send__` if the name `send` clashes with an existing method in
   # *obj*. When the method is identified by a string, the string is converted to a
   # symbol.
-  # 
+  #
   #     class Klass
   #       def hello(*args)
   #         "Hello " + args.join(' ')
@@ -110,48 +110,48 @@ class BasicObject
   #     end
   #     k = Klass.new
   #     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
-  # 
+  #
   def __send__: (String | Symbol arg0, *untyped args) -> untyped
 
   # Equality --- At the `Object` level, `==` returns `true` only if `obj` and
   # `other` are the same object. Typically, this method is overridden in
   # descendant classes to provide class-specific meaning.
-  # 
+  #
   # Unlike `==`, the `equal?` method should never be overridden by subclasses as
   # it is used to determine object identity (that is, `a.equal?(b)` if and only if
   # `a` is the same object as `b`):
-  # 
+  #
   #     obj = "a"
   #     other = obj.dup
-  # 
+  #
   #     obj == other      #=> true
   #     obj.equal? other  #=> false
   #     obj.equal? obj    #=> true
-  # 
+  #
   # The `eql?` method returns `true` if `obj` and `other` refer to the same hash
   # key.  This is used by Hash to test members for equality.  For objects of class
   # `Object`, `eql?` is synonymous with `==`.  Subclasses normally continue this
   # tradition by aliasing `eql?` to their overridden `==` method, but there are
   # exceptions.  `Numeric` types, for example, perform type conversion across
   # `==`, but not across `eql?`, so:
-  # 
+  #
   #     1 == 1.0     #=> true
   #     1.eql? 1.0   #=> false
-  # 
+  #
   def equal?: (untyped other) -> bool
 
   # Evaluates a string containing Ruby source code, or the given block, within the
   # context of the receiver (*obj*). In order to set the context, the variable
   # `self` is set to *obj* while the code is executing, giving the code access to
   # *obj*'s instance variables and private methods.
-  # 
+  #
   # When `instance_eval` is given a block, *obj* is also passed in as the block's
   # only argument.
-  # 
+  #
   # When `instance_eval` is given a `String`, the optional second and third
   # parameters supply a filename and starting line number that are used when
   # reporting compilation errors.
-  # 
+  #
   #     class KlassWithSecret
   #       def initialize
   #         @secret = 99
@@ -165,7 +165,7 @@ class BasicObject
   #     k.instance_eval { @secret }          #=> 99
   #     k.instance_eval { the_secret }       #=> "Ssssh! The secret is 99."
   #     k.instance_eval {|obj| obj == self } #=> true
-  # 
+  #
   def instance_eval: (String, ?String filename, ?Integer lineno) -> untyped
                    | [U] () { (self) -> U } -> U
 
@@ -173,7 +173,7 @@ class BasicObject
   # to set the context, the variable `self` is set to *obj* while the code is
   # executing, giving the code access to *obj*'s instance variables.  Arguments
   # are passed as block parameters.
-  # 
+  #
   #     class KlassWithSecret
   #       def initialize
   #         @secret = 99
@@ -181,11 +181,11 @@ class BasicObject
   #     end
   #     k = KlassWithSecret.new
   #     k.instance_exec(5) {|x| @secret+x }   #=> 104
-  # 
+  #
   def instance_exec: [U, V] (*V args) { (*V args) -> U } -> U
 
   # Not documented
-  # 
+  #
   def initialize: () -> void
 
   private
@@ -199,7 +199,7 @@ class BasicObject
   # method. The example below creates a class `Roman`, which responds to methods
   # with names consisting of roman numerals, returning the corresponding integer
   # values.
-  # 
+  #
   #     class Roman
   #       def roman_to_int(str)
   #         # ...
@@ -209,16 +209,16 @@ class BasicObject
   #         roman_to_int(str)
   #       end
   #     end
-  # 
+  #
   #     r = Roman.new
   #     r.iv      #=> 4
   #     r.xxiii   #=> 23
   #     r.mm      #=> 2000
-  # 
+  #
   def method_missing: (Symbol, *untyped) -> untyped
 
   # Invoked as a callback whenever a singleton method is added to the receiver.
-  # 
+  #
   #     module Chatty
   #       def Chatty.singleton_method_added(id)
   #         puts "Adding #{id.id2name}"
@@ -227,18 +227,18 @@ class BasicObject
   #       def two()          end
   #       def Chatty.three() end
   #     end
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     Adding singleton_method_added
   #     Adding one
   #     Adding three
-  # 
+  #
   def singleton_method_added: (Symbol) -> void
 
   # Invoked as a callback whenever a singleton method is removed from the
   # receiver.
-  # 
+  #
   #     module Chatty
   #       def Chatty.singleton_method_removed(id)
   #         puts "Removing #{id.id2name}"
@@ -251,17 +251,17 @@ class BasicObject
   #         remove_method :one
   #       end
   #     end
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     Removing three
   #     Removing one
-  # 
+  #
   def singleton_method_removed: (Symbol) -> void
 
   # Invoked as a callback whenever a singleton method is undefined in the
   # receiver.
-  # 
+  #
   #     module Chatty
   #       def Chatty.singleton_method_undefined(id)
   #         puts "Undefining #{id.id2name}"
@@ -271,10 +271,10 @@ class BasicObject
   #          undef_method(:one)
   #       end
   #     end
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     Undefining one
-  # 
+  #
   def singleton_method_undefined: (Symbol) -> void
 end

data/{stdlib/builtin → core}/binding.rbs

@@ -4,10 +4,10 @@
 # in this context are all retained. Binding objects can be created using
 # Kernel#binding, and are made available to the callback of
 # Kernel#set_trace_func and instances of TracePoint.
-# 
+#
 # These binding objects can be passed as the second argument of the Kernel#eval
 # method, establishing an environment for the evaluation.
-# 
+#
 #     class Demo
 #       def initialize(n)
 #         @secret = n
@@ -16,39 +16,39 @@
 #         binding
 #       end
 #     end
-# 
+#
 #     k1 = Demo.new(99)
 #     b1 = k1.get_binding
 #     k2 = Demo.new(-3)
 #     b2 = k2.get_binding
-# 
+#
 #     eval("@secret", b1)   #=> 99
 #     eval("@secret", b2)   #=> -3
 #     eval("@secret")       #=> nil
-# 
+#
 # Binding objects have no class-specific methods.
-# 
+#
 class Binding
   public
 
   # Evaluates the Ruby expression(s) in *string*, in the *binding*'s context.  If
   # the optional *filename* and *lineno* parameters are present, they will be used
   # when reporting syntax errors.
-  # 
+  #
   #     def get_binding(param)
   #       binding
   #     end
   #     b = get_binding("hello")
   #     b.eval("param")   #=> "hello"
-  # 
+  #
   def eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
 
   # Opens an IRB session where `binding.irb` is called which allows for
   # interactive debugging. You can call any methods or variables available in the
   # current scope, and mutate state if you need to.
-  # 
+  #
   # Given a Ruby file called `potato.rb` containing the following code:
-  # 
+  #
   #     class Potato
   #       def initialize
   #         @cooked = false
@@ -56,16 +56,16 @@ class Binding
   #         puts "Cooked potato: #{@cooked}"
   #       end
   #     end
-  # 
+  #
   #     Potato.new
-  # 
+  #
   # Running `ruby potato.rb` will open an IRB session where `binding.irb` is
   # called, and you will see the following:
-  # 
+  #
   #     $ ruby potato.rb
-  # 
+  #
   #     From: potato.rb @ line 4 :
-  # 
+  #
   #         1: class Potato
   #         2:   def initialize
   #         3:     @cooked = false
@@ -75,12 +75,12 @@ class Binding
   #         7: end
   #         8:
   #         9: Potato.new
-  # 
+  #
   #     irb(#<Potato:0x00007feea1916670>):001:0>
-  # 
+  #
   # You can type any valid Ruby code and it will be evaluated in the current
   # context. This allows you to debug without having to run your code repeatedly:
-  # 
+  #
   #     irb(#<Potato:0x00007feea1916670>):001:0> @cooked
   #     => false
   #     irb(#<Potato:0x00007feea1916670>):002:0> self.class
@@ -89,89 +89,89 @@ class Binding
   #     => ".../2.5.1/lib/ruby/2.5.0/irb/workspace.rb:85:in `eval'"
   #     irb(#<Potato:0x00007feea1916670>):004:0> @cooked = true
   #     => true
-  # 
+  #
   # You can exit the IRB session with the `exit` command. Note that exiting will
   # resume execution where `binding.irb` had paused it, as you can see from the
   # output printed to standard output in this example:
-  # 
+  #
   #     irb(#<Potato:0x00007feea1916670>):005:0> exit
   #     Cooked potato: true
-  # 
+  #
   # See IRB@IRB+Usage for more information.
-  # 
+  #
   def irb: () -> void
 
   # Returns `true` if a local variable `symbol` exists.
-  # 
+  #
   #     def foo
   #       a = 1
   #       binding.local_variable_defined?(:a) #=> true
   #       binding.local_variable_defined?(:b) #=> false
   #     end
-  # 
+  #
   # This method is the short version of the following code:
-  # 
+  #
   #     binding.eval("defined?(#{symbol}) == 'local-variable'")
-  # 
+  #
   def local_variable_defined?: (String | Symbol symbol) -> bool
 
   # Returns the value of the local variable `symbol`.
-  # 
+  #
   #     def foo
   #       a = 1
   #       binding.local_variable_get(:a) #=> 1
   #       binding.local_variable_get(:b) #=> NameError
   #     end
-  # 
+  #
   # This method is the short version of the following code:
-  # 
+  #
   #     binding.eval("#{symbol}")
-  # 
+  #
   def local_variable_get: (String | Symbol symbol) -> untyped
 
   # Set local variable named `symbol` as `obj`.
-  # 
+  #
   #     def foo
   #       a = 1
   #       bind = binding
   #       bind.local_variable_set(:a, 2) # set existing local variable `a'
   #       bind.local_variable_set(:b, 3) # create new local variable `b'
   #                                      # `b' exists only in binding
-  # 
+  #
   #       p bind.local_variable_get(:a)  #=> 2
   #       p bind.local_variable_get(:b)  #=> 3
   #       p a                            #=> 2
   #       p b                            #=> NameError
   #     end
-  # 
+  #
   # This method behaves similarly to the following code:
-  # 
+  #
   #     binding.eval("#{symbol} = #{obj}")
-  # 
+  #
   # if `obj` can be dumped in Ruby code.
-  # 
+  #
   def local_variable_set: [U] (String | Symbol symbol, U obj) -> U
 
   # Returns the names of the binding's local variables as symbols.
-  # 
+  #
   #     def foo
   #       a = 1
   #       2.times do |n|
   #         binding.local_variables #=> [:a, :n]
   #       end
   #     end
-  # 
+  #
   # This method is the short version of the following code:
-  # 
+  #
   #     binding.eval("local_variables")
-  # 
+  #
   def local_variables: () -> Array[Symbol]
 
   # Returns the bound receiver of the binding object.
-  # 
+  #
   def receiver: () -> untyped
 
   # Returns the Ruby source filename and line number of the binding object.
-  # 
+  #
   def source_location: () -> [ String, Integer ]
 end