rbs 0.12.0 → 0.14.0

data/stdlib/builtin/kernel.rbs

@@ -1,16 +1,18 @@
 # The [Kernel](Kernel) module is included by class
 # [Object](https://ruby-doc.org/core-2.6.3/Object.html), so its methods
 # are available in every Ruby object.
-# 
+#
 # The [Kernel](Kernel) instance methods are documented
 # in class [Object](https://ruby-doc.org/core-2.6.3/Object.html) while the
 # module methods are documented here. These methods are called without a
 # receiver and thus can be called in functional form:
-# 
+#
 # ```ruby
 # sprintf "%.1f", 1.234 #=> "1.2"
 # ```
 module Kernel
+  private
+
   def caller: (?Integer start_or_range, ?Integer length) -> ::Array[String]?
             | (?::Range[Integer] start_or_range) -> ::Array[String]?
             | () -> ::Array[String]
@@ -22,13 +24,13 @@ module Kernel
            | () { (Object tag) -> untyped } -> untyped
 
   # In a perfect world this should be:
-  # 
+  #
   #   returns(T.class_of(T.self_type))
-  # 
+  #
   # but that doesn't work (yet). Even making it:
-  # 
+  #
   #   returns(Class)
-  # 
+  #
   # is very surprising since users expect their methods to be present.
   # So we settle for untyped.
   def `class`: () -> untyped
@@ -40,7 +42,7 @@ module Kernel
 
   # Returns `true` if `yield` would execute a block in the current context.
   # The `iterator?` form is mildly deprecated.
-  # 
+  #
   # ```ruby
   # def try
   #   if block_given?
@@ -57,7 +59,7 @@ module Kernel
   alias block_given? iterator?
 
   # Returns the names of the current local variables.
-  # 
+  #
   # ```ruby
   # fred = 1
   # for i in 1..10
@@ -100,12 +102,12 @@ module Kernel
   # collect the termination statuses of its children or use `Process.detach`
   # to register disinterest in their status; otherwise, the operating system
   # may accumulate zombie processes.
-  # 
+  #
   # The thread calling fork is the only thread in the created child process.
   # fork doesn’t copy other threads.
-  # 
+  #
   # If fork is not usable, Process.respond\_to?(:fork) returns false.
-  # 
+  #
   # Note that fork(2) is not available on some platforms like Windows and
   # NetBSD 4. Therefore you should use spawn() instead of fork().
   def fork: () -> Integer?
@@ -177,16 +179,16 @@ module Kernel
 
   # Returns `arg` as an [Array](https://ruby-doc.org/core-2.6.3/Array.html)
   # .
-  # 
+  #
   # First tries to call `to_ary` on `arg`, then `to_a` . If `arg` does not
   # respond to `to_ary` or `to_a`, returns an
   # [Array](https://ruby-doc.org/core-2.6.3/Array.html) of length 1
   # containing `arg` .
-  # 
+  #
   # If `to_ary` or `to_a` returns something other than an
   # [Array](https://ruby-doc.org/core-2.6.3/Array.html), raises a
   # `TypeError` .
-  # 
+  #
   # ```ruby
   # Array(["a", "b"])  #=> ["a", "b"]
   # Array(1..5)        #=> [1, 2, 3, 4, 5]
@@ -243,7 +245,7 @@ module Kernel
   # at the point of call. This object can be used when calling `eval` to
   # execute the evaluated command in this environment. See also the
   # description of class `Binding` .
-  # 
+  #
   # ```ruby
   # def get_binding(param)
   #   binding
@@ -258,7 +260,7 @@ module Kernel
   # to return a status code to the invoking environment. `true` and `FALSE`
   # of *status* means success and failure respectively. The interpretation
   # of other integer values are system dependent.
-  # 
+  #
   # ```ruby
   # begin
   #   exit
@@ -268,25 +270,25 @@ module Kernel
   # end
   # puts "after begin block"
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     rescued a SystemExit exception
   #     after begin block
-  # 
+  #
   # Just prior to termination, Ruby executes any `at_exit` functions (see
   # Kernel::at\_exit) and runs any object finalizers (see
   # [ObjectSpace.define\_finalizer](https://ruby-doc.org/core-2.6.3/ObjectSpace.html#method-c-define_finalizer)
   # ).
-  # 
+  #
   # ```ruby
   # at_exit { puts "at_exit function" }
   # ObjectSpace.define_finalizer("string",  proc { puts "in finalizer" })
   # exit
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     at_exit function
   #     in finalizer
   def exit: () -> bot
@@ -323,7 +325,7 @@ module Kernel
   def gets: (?String arg0, ?Integer arg1) -> String?
 
   # Returns an array of the names of global variables.
-  # 
+  #
   # ```ruby
   # global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
   # ```
@@ -332,9 +334,9 @@ module Kernel
   def load: (String filename, ?bool arg0) -> bool
 
   # Repeatedly executes the block.
-  # 
+  #
   # If no block is given, an enumerator is returned instead.
-  # 
+  #
   # ```ruby
   # loop do
   #   print "Input: "
@@ -343,18 +345,18 @@ module Kernel
   #   # ...
   # end
   # ```
-  # 
+  #
   # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html)
   # raised in the block breaks the loop. In this case, loop returns the
   # "result" value stored in the exception.
-  # 
+  #
   # ```ruby
   # enum = Enumerator.new { |y|
   #   y << "one"
   #   y << "two"
   #   :ok
   # }
-  # 
+  #
   # result = loop {
   #   puts enum.next
   # } #=> :ok
@@ -370,16 +372,16 @@ module Kernel
   # the output record separator ( `$\` ) is not `nil`, it will be appended
   # to the output. If no arguments are given, prints `$_` . Objects that
   # aren’t strings will be converted by calling their `to_s` method.
-  # 
+  #
   # ```ruby
   # print "cat", [1,2,3], 99, "\n"
   # $, = ", "
   # $\ = "\n"
   # print "cat", [1,2,3], 99
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     cat12399
   #     cat, 1, 2, 3, 99
   def print: (*Kernel args) -> nil
@@ -406,35 +408,35 @@ module Kernel
   # If called without an argument, or if `max.to_i.abs == 0`, rand returns
   # a pseudo-random floating point number between 0.0 and 1.0, including 0.0
   # and excluding 1.0.
-  # 
+  #
   # ```ruby
   # rand        #=> 0.2725926052826416
   # ```
-  # 
+  #
   # When `max.abs` is greater than or equal to 1, `rand` returns a
   # pseudo-random integer greater than or equal to 0 and less than
   # `max.to_i.abs` .
-  # 
+  #
   # ```ruby
   # rand(100)   #=> 12
   # ```
-  # 
+  #
   # When `max` is a [Range](https://ruby-doc.org/core-2.6.3/Range.html),
   # `rand` returns a random number where range.member?(number) == true.
-  # 
+  #
   # Negative or floating point values for `max` are allowed, but may give
   # surprising results.
-  # 
+  #
   # ```ruby
   # rand(-100) # => 87
   # rand(-0.5) # => 0.8130921818028143
   # rand(1.9)  # equivalent to rand(1), which is always 0
   # ```
-  # 
+  #
   # [\#srand](Kernel.downloaded.ruby_doc#method-i-srand) may be used to
   # ensure that sequences of random numbers are reproducible between
   # different runs of a program.
-  # 
+  #
   # See also
   # [Random\#rand](https://ruby-doc.org/core-2.6.3/Random.html#method-i-rand)
   # .
@@ -466,109 +468,109 @@ module Kernel
 
   # Replaces the current process by running the given external *command* ,
   # which can take one of the following forms:
-  # 
+  #
   #   - `exec(commandline)`
   #     command line string which is passed to the standard shell
-  # 
+  #
   #   - `exec(cmdname, arg1, ...)`
   #     command name and one or more arguments (no shell)
-  # 
+  #
   #   - `exec([cmdname, argv0], arg1, ...)`
   #     command name, [argv](https://ruby-doc.org/core-2.6.3/0) and zero or
   #     more arguments (no shell)
-  # 
+  #
   # In the first form, the string is taken as a command line that is subject
   # to shell expansion before being executed.
-  # 
+  #
   # The standard shell always means `"/bin/sh"` on Unix-like systems, same
   # as `ENV["RUBYSHELL"]` (or `ENV["COMSPEC"]` on Windows NT series), and
   # similar.
-  # 
+  #
   # If the string from the first form ( `exec("command")` ) follows these
   # simple rules:
-  # 
+  #
   #   - no meta characters
-  # 
+  #
   #   - no shell reserved word and no special built-in
-  # 
+  #
   #   - Ruby invokes the command directly without shell
-  # 
+  #
   # You can force shell invocation by adding “;” to the string (because “;”
   # is a meta character).
-  # 
+  #
   # Note that this behavior is observable by pid obtained (return value of
   # spawn() and
   # [IO\#pid](https://ruby-doc.org/core-2.6.3/IO.html#method-i-pid) for
   # [IO.popen](https://ruby-doc.org/core-2.6.3/IO.html#method-c-popen) ) is
   # the pid of the invoked command, not shell.
-  # 
+  #
   # In the second form ( `exec("command1", "arg1", ...)` ), the first is
   # taken as a command name and the rest are passed as parameters to command
   # with no shell expansion.
-  # 
+  #
   # In the third form ( `exec(["command", "argv0"], "arg1", ...)` ),
   # starting a two-element array at the beginning of the command, the first
   # element is the command to be executed, and the second argument is used
   # as the `argv[0]` value, which may show up in process listings.
-  # 
+  #
   # In order to execute the command, one of the `exec(2)` system calls are
   # used, so the running command may inherit some of the environment of the
   # original program (including open file descriptors).
-  # 
+  #
   # This behavior is modified by the given `env` and `options` parameters.
   # See ::spawn for details.
-  # 
+  #
   # If the command fails to execute (typically `Errno::ENOENT` when it was
   # not found) a
   # [SystemCallError](https://ruby-doc.org/core-2.6.3/SystemCallError.html)
   # exception is raised.
-  # 
+  #
   # This method modifies process attributes according to given `options`
   # before `exec(2)` system call. See ::spawn for more details about the
   # given `options` .
-  # 
+  #
   # The modified attributes may be retained when `exec(2)` system call
   # fails.
-  # 
+  #
   # For example, hard resource limits are not restorable.
-  # 
+  #
   # Consider to create a child process using ::spawn or
   # [\#system](Kernel.downloaded.ruby_doc#method-i-system) if this is not
   # acceptable.
-  # 
+  #
   # ```ruby
   # exec "echo *"       # echoes list of files in current directory
   # # never get here
-  # 
+  #
   # exec "echo", "*"    # echoes an asterisk
   # # never get here
   # ```
   def exec: (*String args) -> bot
 
   # Executes *command…* in a subshell. *command…* is one of following forms.
-  # 
+  #
   #     commandline                 : command line string which is passed to the standard shell
   #     cmdname, arg1, ...          : command name and one or more arguments (no shell)
   #     [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
-  # 
+  #
   # system returns `true` if the command gives zero exit status, `false` for
   # non zero exit status. Returns `nil` if command execution fails. An error
   # status is available in `$?` . The arguments are processed in the same
   # way as for `Kernel.spawn` .
-  # 
+  #
   # The hash arguments, env and options, are same as `exec` and `spawn` .
   # See `Kernel.spawn` for details.
-  # 
+  #
   # ```ruby
   # system("echo *")
   # system("echo", "*")
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     config.h main.rb
   #     *
-  # 
+  #
   # See `Kernel.exec` for the standard shell.
   def system: (*String args) -> (NilClass | FalseClass | TrueClass)
 end

data/stdlib/builtin/match_data.rbs

@@ -95,7 +95,7 @@ class MatchData
   #     f3    #=> "113"
   #     f4    #=> "8"
   #
-  def captures: () -> ::Array[String?] 
+  def captures: () -> ::Array[String?]
 
   # Returns the offset of the character immediately following the end of the *n*th
   # element of the match array in the string. *n* can be a string or symbol to

data/stdlib/builtin/method.rbs

@@ -4,7 +4,7 @@ class Method < Object
 
   # Invokes the *meth* with the specified arguments, returning the method’s
   # return value.
-  # 
+  #
   # ```ruby
   # m = 12.method("+")
   # m.call(3)    #=> 15
@@ -15,12 +15,12 @@ class Method < Object
   # Returns a proc that is the composition of this method and the given *g*
   # . The returned proc takes a variable number of arguments, calls *g* with
   # them then calls this method with the result.
-  # 
+  #
   # ```ruby
   # def f(x)
   #   x * x
   # end
-  # 
+  #
   # f = self.method(:f)
   # g = proc {|x| x + x }
   # p (f << g).call(2) #=> 16
@@ -30,10 +30,10 @@ class Method < Object
   # Invokes the method with `obj` as the parameter like
   # [call](Method.downloaded.ruby_doc#method-i-call). This allows a method
   # object to be the target of a `when` clause in a case statement.
-  # 
+  #
   # ```ruby
   # require 'prime'
-  # 
+  #
   # case 1373
   # when Prime.method(:prime?)
   #   # ...
@@ -44,12 +44,12 @@ class Method < Object
   # Returns a proc that is the composition of this method and the given *g*
   # . The returned proc takes a variable number of arguments, calls *g* with
   # them then calls this method with the result.
-  # 
+  #
   # ```ruby
   # def f(x)
   #   x * x
   # end
-  # 
+  #
   # f = self.method(:f)
   # g = proc {|x| x + x }
   # p (f >> g).call(2) #=> 8
@@ -58,7 +58,7 @@ class Method < Object
 
   # Invokes the *meth* with the specified arguments, returning the method’s
   # return value.
-  # 
+  #
   # ```ruby
   # m = 12.method("+")
   # m.call(3)    #=> 15
@@ -74,7 +74,7 @@ class Method < Object
   # argument being mandatory if any keyword argument is mandatory. For
   # methods written in C, returns -1 if the call takes a variable number of
   # arguments.
-  # 
+  #
   #     class C
   #       def one;    end
   #       def two(a); end
@@ -98,7 +98,7 @@ class Method < Object
   #     c.method(:eight).arity   #=> 1
   #     c.method(:nine).arity    #=> 1
   #     c.method(:ten).arity     #=> -2
-  # 
+  #
   #     "cat".method(:size).arity      #=> 0
   #     "cat".method(:replace).arity   #=> 1
   #     "cat".method(:squeeze).arity   #=> -1
@@ -106,14 +106,14 @@ class Method < Object
   def arity: () -> Integer
 
   # Returns a clone of this method.
-  # 
+  #
   # ```ruby
   # class A
   #   def foo
   #     return "bar"
   #   end
   # end
-  # 
+  #
   # m = A.new.method(:foo)
   # m.call # => "bar"
   # n = m.clone.call # => "bar"
@@ -126,7 +126,7 @@ class Method < Object
   def name: () -> Symbol
 
   # Returns the original name of the method.
-  # 
+  #
   # ```ruby
   # class C
   #   def foo; end
@@ -137,24 +137,24 @@ class Method < Object
   def original_name: () -> Symbol
 
   # Returns the class or module that defines the method. See also receiver.
-  # 
+  #
   # ```ruby
   # (1..3).method(:map).owner #=> Enumerable
   # ```
   def owner: () -> (Class | Module)
 
   # Returns the parameter information of this method.
-  # 
+  #
   # ```ruby
   # def foo(bar); end
   # method(:foo).parameters #=> [[:req, :bar]]
-  # 
+  #
   # def foo(bar, baz, bat, &blk); end
   # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:req, :bat], [:block, :blk]]
-  # 
+  #
   # def foo(bar, *args); end
   # method(:foo).parameters #=> [[:req, :bar], [:rest, :args]]
-  # 
+  #
   # def foo(bar, baz, *args, &blk); end
   # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:rest, :args], [:block, :blk]]
   # ```
@@ -164,7 +164,7 @@ class Method < Object
   ]
 
   # Returns the bound receiver of the method object.
-  # 
+  #
   # ```ruby
   # (1..3).method(:map).receiver # => 1..3
   # ```