rbs 0.2.0

data/stdlib/builtin/string_io.rbs

@@ -0,0 +1,284 @@
+# Pseudo I/O on String object, with interface corresponding to IO.
+#
+# Commonly used to simulate `$stdio` or `$stderr`
+#
+# ### Examples
+#
+#     require 'stringio'
+#
+#     # Writing stream emulation
+#     io = StringIO.new
+#     io.puts "Hello World"
+#     io.string #=> "Hello World\n"
+#
+#     # Reading stream emulation
+#     io = StringIO.new "first\nsecond\nlast\n"
+#     io.getc #=> "f"
+#     io.gets #=> "irst\n"
+#     io.read #=> "second\nlast\n"
+#
+class StringIO
+  # Creates new StringIO instance from with *string* and *mode*.
+  #
+  def initialize: (?String string, ?String? mode) -> void
+
+  # Equivalent to StringIO.new except that when it is called with a block, it
+  # yields with the new instance and closes it, and returns the result which
+  # returned from the block.
+  #
+  def self.open: [U] (?String string, ?String? mode) { (StringIO arg) -> U } -> U
+
+  def <<: (untyped arg0) -> self
+
+  # Puts stream into binary mode. See IO#binmode.
+  #
+  def binmode: () -> self
+
+  # Closes a StringIO. The stream is unavailable for any further data operations;
+  # an `IOError` is raised if such an attempt is made.
+  #
+  def close: () -> nil
+
+  # Closes the read end of a StringIO.  Will raise an `IOError` if the receiver is
+  # not readable.
+  #
+  def close_read: () -> nil
+
+  # Closes the write end of a StringIO.  Will raise an  `IOError` if the receiver
+  # is not writeable.
+  #
+  def close_write: () -> nil
+
+  # Returns `true` if the stream is completely closed, `false` otherwise.
+  #
+  def closed?: () -> bool
+
+  # Returns `true` if the stream is not readable, `false` otherwise.
+  #
+  def closed_read?: () -> bool
+
+  # Returns `true` if the stream is not writable, `false` otherwise.
+  #
+  def closed_write?: () -> bool
+
+  # See IO#each.
+  #
+  def each: (?String sep, ?Integer limit, ?chomp: bool) { (String arg0) -> untyped } -> self
+          | (?String sep, ?Integer limit, ?chomp: bool) -> ::Enumerator[String, self]
+
+  # See IO#each_byte.
+  #
+  def each_byte: () { (Integer arg0) -> untyped } -> self
+               | () -> ::Enumerator[Integer, self]
+
+  # See IO#each_char.
+  #
+  def each_char: () { (String arg0) -> untyped } -> self
+               | () -> ::Enumerator[String, self]
+
+  # See IO#each_codepoint.
+  #
+  def each_codepoint: () { (Integer arg0) -> untyped } -> self
+                    | () -> ::Enumerator[Integer, self]
+
+  # Returns true if the stream is at the end of the data (underlying string). The
+  # stream must be opened for reading or an `IOError` will be raised.
+  #
+  def eof: () -> bool
+
+  # Raises NotImplementedError.
+  #
+  def fcntl: (Integer integer_cmd, String | Integer arg) -> Integer
+
+  # Returns `nil`.  Just for compatibility to IO.
+  #
+  def fileno: () -> nil
+
+  # Returns an object itself.  Just for compatibility to IO.
+  #
+  def flush: () -> self
+
+  # Returns 0.  Just for compatibility to IO.
+  #
+  def fsync: () -> Integer?
+
+  # See IO#getbyte.
+  #
+  def getbyte: () -> Integer?
+
+  # See IO#getc.
+  #
+  def getc: () -> String?
+
+  # See IO#gets.
+  #
+  def gets: (?String sep, ?Integer limit, ?chomp: bool) -> String?
+
+  # Returns the Encoding of the internal string if conversion is specified. 
+  # Otherwise returns `nil`.
+  #
+  def internal_encoding: () -> Encoding
+
+  # Returns the Encoding object that represents the encoding of the file. If the
+  # stream is write mode and no encoding is specified, returns `nil`.
+  #
+  def external_encoding: () -> Encoding
+
+  # Returns `false`.  Just for compatibility to IO.
+  #
+  def isatty: () -> bool
+
+  # Returns the current line number. The stream must be opened for reading.
+  # `lineno` counts the number of times  `gets` is called, rather than the number
+  # of newlines  encountered. The two values will differ if `gets` is  called with
+  # a separator other than newline.  See also the  `$.` variable.
+  #
+  def lineno: () -> Integer
+
+  # Manually sets the current line number to the given value. `$.` is updated only
+  # on the next read.
+  #
+  def lineno=: (Integer arg0) -> Integer
+
+  # Returns `nil`.  Just for compatibility to IO.
+  #
+  def pid: () -> nil
+
+  # Returns the current offset (in bytes).
+  #
+  def pos: () -> Integer
+
+  # Seeks to the given position (in bytes).
+  #
+  def pos=: (Integer arg0) -> Integer
+
+  def print: (*untyped arg0) -> nil
+
+  def printf: (String format_string, *untyped arg0) -> nil
+
+  # See IO#putc.
+  #
+  def putc: (Numeric | String arg0) -> untyped
+
+  def puts: (*untyped arg0) -> nil
+
+  # See IO#read.
+  #
+  def read: (?Integer length, ?String outbuf) -> String?
+
+  def read_nonblock: (Integer len) -> String
+                   | (Integer len, ?String buf) -> String
+
+  def readbyte: () -> Integer
+
+  def readchar: () -> String
+
+  def readline: (?String sep, ?Integer limit) -> String
+
+  # See IO#readlines.
+  #
+  def readlines: (?String sep, ?Integer limit, ?chomp: bool) -> ::Array[String]
+
+  def readpartial: (Integer maxlen) -> String
+                 | (Integer maxlen, ?String outbuf) -> String
+
+  # Reinitializes the stream with the given *other_StrIO* or *string* and *mode*
+  # (see StringIO#new).
+  #
+  def reopen: (StringIO other) -> self
+            | (String other, ?String mode_str) -> self
+
+  # Positions the stream to the beginning of input, resetting `lineno` to zero.
+  #
+  def rewind: () -> Integer
+
+  # Seeks to a given offset *amount* in the stream according to the value of
+  # *whence* (see IO#seek).
+  #
+  def seek: (Integer amount, ?Integer whence) -> Integer
+
+  # Specify the encoding of the StringIO as *ext_enc*. Use the default external
+  # encoding if *ext_enc* is nil. 2nd argument *int_enc* and optional hash *opt*
+  # argument are ignored; they are for API compatibility to IO.
+  #
+  def set_encoding: (?String | Encoding ext_or_ext_int_enc) -> self
+                  | (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc) -> self
+
+  # Returns underlying String object, the subject of IO.
+  #
+  def string: () -> String
+
+  # Changes underlying String object, the subject of IO.
+  #
+  def string=: (String str) -> String
+
+  # Returns the size of the buffer string.
+  #
+  def size: () -> Integer
+
+  # Returns `true` always.
+  #
+  def sync: () -> bool
+
+  # Returns the argument unchanged.  Just for compatibility to IO.
+  #
+  def sync=: (bool arg0) -> bool
+
+  def sysread: (Integer maxlen, String outbuf) -> String
+
+  def syswrite: (String arg0) -> Integer
+
+  # Returns the current offset (in bytes).
+  #
+  def tell: () -> Integer
+
+  # Returns `false`.  Just for compatibility to IO.
+  #
+  def tty?: () -> bool
+
+  # See IO#ungetbyte
+  #
+  def ungetbyte: (String | Integer arg0) -> nil
+
+  # Pushes back one character (passed as a parameter) such that a subsequent
+  # buffered read will return it.  There is no limitation for multiple pushbacks
+  # including pushing back behind the beginning of the buffer string.
+  #
+  def ungetc: (String arg0) -> nil
+
+  # Appends the given string to the underlying buffer string. The stream must be
+  # opened for writing.  If the argument is not a string, it will be converted to
+  # a string using `to_s`. Returns the number of bytes written.  See IO#write.
+  #
+  def write: (String arg0) -> Integer
+
+  # This is a deprecated alias for #each_byte.
+  #
+  def bytes: () { (Integer arg0) -> untyped } -> self
+           | () -> ::Enumerator[Integer, self]
+
+  # This is a deprecated alias for #each_char.
+  #
+  def chars: () { (String arg0) -> untyped } -> self
+           | () -> ::Enumerator[String, self]
+
+  # This is a deprecated alias for #each_codepoint.
+  #
+  def codepoints: () { (Integer arg0) -> untyped } -> self
+                | () -> ::Enumerator[Integer, self]
+
+  # See IO#each.
+  #
+  def each_line: (?String sep, ?Integer limit, ?chomp: bool) { (String arg0) -> untyped } -> self
+               | (?String sep, ?Integer limit, ?chomp: bool) -> ::Enumerator[String, self]
+
+  # Returns true if the stream is at the end of the data (underlying string). The
+  # stream must be opened for reading or an `IOError` will be raised.
+  #
+  def eof?: () -> bool
+
+  # This is a deprecated alias for #each_line.
+  #
+  def lines: (?String sep, ?Integer limit) { (String arg0) -> untyped } -> self
+           | (?String sep, ?Integer limit) -> ::Enumerator[String, self]
+end

data/stdlib/builtin/struct.rbs

@@ -0,0 +1,40 @@
+# A [Struct](Struct) is a convenient way to bundle a
+# number of attributes together, using accessor methods, without having to
+# write an explicit class.
+# 
+# The [Struct](Struct) class generates new subclasses
+# that hold a set of members and their values. For each member a reader
+# and writer method is created similar to
+# [Module\#attr\_accessor](https://ruby-doc.org/core-2.6.3/Module.html#method-i-attr_accessor)
+# .
+# 
+# ```ruby
+# Customer = Struct.new(:name, :address) do
+#   def greeting
+#     "Hello #{name}!"
+#   end
+# end
+# 
+# dave = Customer.new("Dave", "123 Main")
+# dave.name     #=> "Dave"
+# dave.greeting #=> "Hello Dave!"
+# ```
+# 
+# See [::new](Struct#method-c-new) for further
+# examples of creating struct subclasses and instances.
+# 
+# In the method descriptions that follow, a "member" parameter refers to a
+# struct member which is either a quoted string ( `"name"` ) or a
+# [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html) ( `:name` ).
+class Struct[Elem] < Object
+  include Enumerable[Elem, Struct[Elem]]
+
+  def initialize: (Symbol | String arg0, *Symbol | String arg1, ?keyword_init: bool keyword_init) -> void
+
+  def each: () { (Elem arg0) -> untyped } -> untyped
+          | () -> self
+
+  def self.members: () -> ::Array[Symbol]
+
+  def new: (*untyped args) -> Struct[untyped]
+end

data/stdlib/builtin/symbol.rbs

@@ -0,0 +1,228 @@
+# Symbol objects represent names inside the Ruby interpreter. They are generated
+# using the `:name` and `:"string"` literals syntax, and by the various `to_sym`
+# methods. The same Symbol object will be created for a given name or string for
+# the duration of a program's execution, regardless of the context or meaning of
+# that name. Thus if `Fred` is a constant in one context, a method in another,
+# and a class in a third, the Symbol `:Fred` will be the same object in all
+# three contexts.
+#
+#     module One
+#       class Fred
+#       end
+#       $f1 = :Fred
+#     end
+#     module Two
+#       Fred = 1
+#       $f2 = :Fred
+#     end
+#     def Fred()
+#     end
+#     $f3 = :Fred
+#     $f1.object_id   #=> 2514190
+#     $f2.object_id   #=> 2514190
+#     $f3.object_id   #=> 2514190
+#
+class Symbol
+  include Comparable
+
+  # Returns an array of all the symbols currently in Ruby's symbol table.
+  #
+  #     Symbol.all_symbols.size    #=> 903
+  #     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
+  #                                     :chown, :EOFError, :$;, :String,
+  #                                     :LOCK_SH, :"setuid?", :$<,
+  #                                     :default_proc, :compact, :extend,
+  #                                     :Tms, :getwd, :$=, :ThreadGroup,
+  #                                     :wait2, :$>]
+  #
+  def self.all_symbols: () -> ::Array[Symbol]
+
+  public
+
+  # Compares `symbol` with `other_symbol` after calling #to_s on each of the
+  # symbols. Returns -1, 0, +1, or `nil` depending on whether `symbol` is less
+  # than, equal to, or greater than `other_symbol`.
+  #
+  # `nil` is returned if the two values are incomparable.
+  #
+  # See String#<=> for more information.
+  #
+  def <=>: (untyped other) -> Integer?
+
+  # Equality---If *sym* and *obj* are exactly the same symbol, returns `true`.
+  #
+  def ==: (untyped obj) -> bool
+
+  # Equality---If *sym* and *obj* are exactly the same symbol, returns `true`.
+  #
+  def ===: (untyped obj) -> bool
+
+  # Returns `sym.to_s =~ obj`.
+  #
+  def =~: (untyped obj) -> Integer?
+
+  # Returns `sym.to_s[]`.
+  #
+  def []: (int index) -> String?
+        | (int start, int length) -> String?
+        | (Range[Integer?] range) -> String?
+        | (Regexp regexp) -> String?
+        | (Regexp regexp, int | String capture) -> String?
+        | (String match_str) -> String?
+
+  # Same as `sym.to_s.capitalize.intern`.
+  #
+  def capitalize: () -> Symbol
+                | (:ascii | :lithuanian | :turkic) -> Symbol
+                | (:lithuanian, :turkic) -> Symbol
+                | (:turkic, :lithuanian) -> Symbol
+
+  # Case-insensitive version of Symbol#<=>. Currently, case-insensitivity only
+  # works on characters A-Z/a-z, not all of Unicode. This is different from
+  # Symbol#casecmp?.
+  #
+  #     :aBcDeF.casecmp(:abcde)     #=> 1
+  #     :aBcDeF.casecmp(:abcdef)    #=> 0
+  #     :aBcDeF.casecmp(:abcdefg)   #=> -1
+  #     :abcdef.casecmp(:ABCDEF)    #=> 0
+  #
+  # `nil` is returned if the two symbols have incompatible encodings, or if
+  # `other_symbol` is not a symbol.
+  #
+  #     :foo.casecmp(2)   #=> nil
+  #     "\u{e4 f6 fc}".encode("ISO-8859-1").to_sym.casecmp(:"\u{c4 d6 dc}")   #=> nil
+  #
+  def casecmp: (untyped other) -> Integer?
+
+  # Returns `true` if `sym` and `other_symbol` are equal after Unicode case
+  # folding, `false` if they are not equal.
+  #
+  #     :aBcDeF.casecmp?(:abcde)     #=> false
+  #     :aBcDeF.casecmp?(:abcdef)    #=> true
+  #     :aBcDeF.casecmp?(:abcdefg)   #=> false
+  #     :abcdef.casecmp?(:ABCDEF)    #=> true
+  #     :"\u{e4 f6 fc}".casecmp?(:"\u{c4 d6 dc}")   #=> true
+  #
+  # `nil` is returned if the two symbols have incompatible encodings, or if
+  # `other_symbol` is not a symbol.
+  #
+  #     :foo.casecmp?(2)   #=> nil
+  #     "\u{e4 f6 fc}".encode("ISO-8859-1").to_sym.casecmp?(:"\u{c4 d6 dc}")   #=> nil
+  #
+  def casecmp?: (untyped other) -> bool
+
+  # Same as `sym.to_s.downcase.intern`.
+  #
+  def downcase: () -> Symbol
+              | (:ascii | :fold | :lithuanian | :turkic) -> Symbol
+              | (:lithuanian, :turkic) -> Symbol
+              | (:turkic, :lithuanian) -> Symbol
+
+  # Returns whether *sym* is :"" or not.
+  #
+  def empty?: () -> bool
+
+  # Returns the Encoding object that represents the encoding of *sym*.
+  #
+  def encoding: () -> Encoding
+
+  # Returns true if `sym` ends with one of the `suffixes` given.
+  #
+  #     :hello.end_with?("ello")               #=> true
+  #
+  #     # returns true if one of the +suffixes+ matches.
+  #     :hello.end_with?("heaven", "ello")     #=> true
+  #     :hello.end_with?("heaven", "paradise") #=> false
+  #
+  def end_with?: (*string suffixes) -> bool
+
+  # Returns the name or string corresponding to *sym*.
+  #
+  #     :fred.id2name   #=> "fred"
+  #     :ginger.to_s    #=> "ginger"
+  #
+  def id2name: () -> String
+
+  # Returns the representation of *sym* as a symbol literal.
+  #
+  #     :fred.inspect   #=> ":fred"
+  #
+  def inspect: () -> String
+
+  # In general, `to_sym` returns the Symbol corresponding to an object. As *sym*
+  # is already a symbol, `self` is returned in this case.
+  #
+  def intern: () -> self
+
+  # Same as `sym.to_s.length`.
+  #
+  def length: () -> Integer
+
+  # Returns `sym.to_s.match`.
+  #
+  def match: (Regexp | string pattern, ?int pos) -> MatchData?
+           | (Regexp | string pattern, ?int pos) { (MatchData) -> void } -> untyped
+
+  # Returns `sym.to_s.match?`.
+  #
+  def match?: (Regexp | string pattern, ?int pos) -> bool
+
+  # Same as `sym.to_s.succ.intern`.
+  #
+  def next: () -> Symbol
+
+  # Same as `sym.to_s.length`.
+  #
+  alias size length
+
+  # Returns `sym.to_s[]`.
+  #
+  alias slice `[]`
+
+  # Returns true if `sym` starts with one of the `prefixes` given. Each of the
+  # `prefixes` should be a String or a Regexp.
+  #
+  #     :hello.start_with?("hell")               #=> true
+  #     :hello.start_with?(/H/i)                 #=> true
+  #
+  #     # returns true if one of the prefixes matches.
+  #     :hello.start_with?("heaven", "hell")     #=> true
+  #     :hello.start_with?("heaven", "paradise") #=> false
+  def start_with?: (*string prefixes) -> bool
+
+  # Same as `sym.to_s.succ.intern`.
+  #
+  alias succ next
+
+  # Same as `sym.to_s.swapcase.intern`.
+  #
+  def swapcase: () -> Symbol
+              | (:ascii | :lithuanian | :turkic) -> Symbol
+              | (:lithuanian, :turkic) -> Symbol
+              | (:turkic, :lithuanian) -> Symbol
+
+  # Returns a *Proc* object which responds to the given method by *sym*.
+  #
+  #     (1..3).collect(&:to_s)  #=> ["1", "2", "3"]
+  #
+  def to_proc: () -> Proc
+
+  # Returns the name or string corresponding to *sym*.
+  #
+  #     :fred.id2name   #=> "fred"
+  #     :ginger.to_s    #=> "ginger"
+  #
+  alias to_s id2name
+
+  # In general, `to_sym` returns the Symbol corresponding to an object. As *sym*
+  # is already a symbol, `self` is returned in this case.
+  #
+  alias to_sym intern
+
+  # Same as `sym.to_s.upcase.intern`.
+  #
+  def upcase: () -> Symbol
+            | (:ascii | :lithuanian | :turkic) -> Symbol
+            | (:lithuanian, :turkic) -> Symbol
+            | (:turkic, :lithuanian) -> Symbol
+end