rbs 0.14.0 → 0.18.1

data/stdlib/base64/{base64.rbs → 0/base64.rbs}

@@ -67,5 +67,5 @@ module Base64
   # 64 Encoding with URL and Filename Safe Alphabet'' in RFC 4648. The alphabet
   # uses '-' instead of '+' and '_' instead of '/'. Note that the result can still
   # contain '='. You can remove the padding by setting `padding` as false.
-  def self?.urlsafe_encode64: (String bin, ?padding: bool) -> String
+  def self?.urlsafe_encode64: (String bin, ?padding: boolish) -> String
 end

data/stdlib/coverage/{coverage.rbs → 0/coverage.rbs}

@@ -49,7 +49,7 @@ module Coverage
   # `clear` is true, it clears the counters to zero. If `stop` is true, it
   # disables coverage measurement.
   #
-  def self.result: (?stop: bool, ?clear: bool) -> Hash[String, untyped]
+  def self.result: (?stop: boolish, ?clear: boolish) -> Hash[String, untyped]
 
   # Returns true if coverage stats are currently being collected (after
   # Coverage.start call, but before Coverage.result call)
@@ -58,5 +58,5 @@ module Coverage
 
   # Enables coverage measurement.
   #
-  def self.start: (?lines: bool, ?branches: bool, ?methods: bool, ?oneshot_lines: bool) -> nil
+  def self.start: (?lines: boolish, ?branches: boolish, ?methods: boolish, ?oneshot_lines: boolish) -> nil
 end

data/stdlib/csv/{csv.rbs → 0/csv.rbs}

@@ -159,7 +159,7 @@
 # with it.
 #
 class CSV < Object
-  include Enumerable[untyped, untyped]
+  include Enumerable[untyped]
 
   # This method is intended as the primary interface for reading CSV files. You
   # pass a `path` and any `options` you wish to set for the read. Each row of file
@@ -407,7 +407,7 @@ CSV::VERSION: String
 # processing is activated.
 #
 class CSV::Row < Object
-  include Enumerable[untyped, untyped]
+  include Enumerable[untyped]
 
   # If a two-element Array is provided, it is assumed to be a header and field and
   # the pair is appended. A Hash works the same way with the key being the header
@@ -578,7 +578,7 @@ end
 # processing is activated.
 #
 class CSV::Table[out Elem] < Object
-  include Enumerable[untyped, untyped]
+  include Enumerable[untyped]
 
   # Constructs a new CSV::Table from `array_of_rows`, which are expected to be
   # CSV::Row objects. All rows are assumed to have the same headers.
@@ -755,7 +755,7 @@ class CSV::Table[out Elem] < Object
   # This method assumes you want the Table.headers(), unless you explicitly pass
   # `:write_headers => false`.
   #
-  def to_csv: (?write_headers: bool, **untyped) -> untyped
+  def to_csv: (?write_headers: boolish, **untyped) -> untyped
 
   alias to_s to_csv
 

data/stdlib/date/{date.rbs → 0/date.rbs}

@@ -178,7 +178,7 @@ class Date
   #
   #     Date._parse('2001-02-03') #=> {:year=>2001, :mon=>2, :mday=>3}
   #
-  def self._parse: (String str, ?bool complete) -> Hash[Symbol, Integer]
+  def self._parse: (String str, ?boolish complete) -> Hash[Symbol, Integer]
 
   # Returns a hash of parsed elements.
   #
@@ -328,7 +328,7 @@ class Date
   #     Date.parse('20010203')            #=> #<Date: 2001-02-03 ...>
   #     Date.parse('3rd Feb 2001')        #=> #<Date: 2001-02-03 ...>
   #
-  def self.parse: (String str, ?bool complete, ?Integer start) -> Date
+  def self.parse: (String str, ?boolish complete, ?Integer start) -> Date
 
   # Creates a new Date object by parsing from a string according to some typical
   # RFC 2822 formats.

data/stdlib/date/{date_time.rbs → 0/date_time.rbs}

@@ -236,7 +236,7 @@ class DateTime < Date
   #     DateTime.parse('3rd Feb 2001 04:05:06 PM')
   #                               #=> #<DateTime: 2001-02-03T16:05:06+00:00 ...>
   #
-  def self.parse: (String str, ?bool complete, ?Integer start) -> DateTime
+  def self.parse: (String str, ?boolish complete, ?Integer start) -> DateTime
 
   # Creates a new DateTime object by parsing from a string according to some
   # typical RFC 2822 formats.

data/stdlib/dbm/0/dbm.rbs

@@ -0,0 +1,277 @@
+# ## Introduction
+#
+# The DBM class provides a wrapper to a Unix-style
+# [dbm](http://en.wikipedia.org/wiki/Dbm) or Database Manager library.
+#
+# Dbm databases do not have tables or columns; they are simple key-value data
+# stores, like a Ruby Hash except not resident in RAM. Keys and values must be
+# strings.
+#
+# The exact library used depends on how Ruby was compiled. It could be any of
+# the following:
+#
+# *   The original ndbm library is released in 4.3BSD. It is based on dbm
+#     library in Unix Version 7 but has different API to support multiple
+#     databases in a process.
+# *   [Berkeley DB](http://en.wikipedia.org/wiki/Berkeley_DB) versions 1 thru 6,
+#     also known as BDB and Sleepycat DB, now owned by Oracle Corporation.
+# *   Berkeley DB 1.x, still found in 4.4BSD derivatives (FreeBSD, OpenBSD,
+#     etc).
+# *   [gdbm](http://www.gnu.org/software/gdbm/), the GNU implementation of dbm.
+# *   [qdbm](http://fallabs.com/qdbm/index.html), another open source
+#     reimplementation of dbm.
+#
+#
+# All of these dbm implementations have their own Ruby interfaces available,
+# which provide richer (but varying) APIs.
+#
+# ## Cautions
+#
+# Before you decide to use DBM, there are some issues you should consider:
+#
+# *   Each implementation of dbm has its own file format. Generally, dbm
+#     libraries will not read each other's files. This makes dbm files a bad
+#     choice for data exchange.
+#
+# *   Even running the same OS and the same dbm implementation, the database
+#     file format may depend on the CPU architecture. For example, files may not
+#     be portable between PowerPC and 386, or between 32 and 64 bit Linux.
+#
+# *   Different versions of Berkeley DB use different file formats. A change to
+#     the OS may therefore break DBM access to existing files.
+#
+# *   Data size limits vary between implementations. Original Berkeley DB was
+#     limited to 2GB of data. Dbm libraries also sometimes limit the total size
+#     of a key/value pair, and the total size of all the keys that hash to the
+#     same value. These limits can be as little as 512 bytes. That said, gdbm
+#     and recent versions of Berkeley DB do away with these limits.
+#
+#
+# Given the above cautions, DBM is not a good choice for long term storage of
+# important data. It is probably best used as a fast and easy alternative to a
+# Hash for processing large amounts of data.
+#
+# ## Example
+#
+#     require 'dbm'
+#     db = DBM.open('rfcs', 0666, DBM::WRCREAT)
+#     db['822'] = 'Standard for the Format of ARPA Internet Text Messages'
+#     db['1123'] = 'Requirements for Internet Hosts - Application and Support'
+#     db['3068'] = 'An Anycast Prefix for 6to4 Relay Routers'
+#     puts db['822']
+#
+class DBM
+  include Enumerable[untyped]
+
+  # Open a dbm database and yields it if a block is given. See also `DBM.new`.
+  #
+  def self.open: (*untyped) -> ::DBM
+
+  public
+
+  # Return a value from the database by locating the key string provided.  If the
+  # key is not found, returns nil.
+  #
+  def []: (untyped) -> untyped
+
+  # Stores the specified string value in the database, indexed via the string key
+  # provided.
+  #
+  def []=: (untyped, untyped) -> untyped
+
+  # Deletes all data from the database.
+  #
+  def clear: () -> self
+
+  # Closes the database.
+  #
+  def close: () -> NilClass
+
+  # Returns true if the database is closed, false otherwise.
+  #
+  def closed?: () -> bool
+
+  # Deletes an entry from the database.
+  #
+  def delete: (untyped) -> untyped
+
+  # Deletes all entries for which the code block returns true. Returns self.
+  #
+  def delete_if: () ?{ (untyped) -> bool } -> self
+
+  # Calls the block once for each [key, value] pair in the database. Returns self.
+  #
+  def each: (?untyped, ?untyped) -> Enumerator[untyped, ::DBM]
+
+  # Calls the block once for each key string in the database. Returns self.
+  #
+  def each_key: () -> Enumerator[String, ::DBM]
+
+  # Calls the block once for each [key, value] pair in the database. Returns self.
+  #
+  def each_pair: (?untyped, ?untyped) -> Enumerator[untyped, ::DBM]
+
+  # Calls the block once for each value string in the database. Returns self.
+  #
+  def each_value: () -> Enumerator[untyped, ::DBM]
+
+  # Returns true if the database is empty, false otherwise.
+  #
+  def empty?: () -> bool
+
+  # Return a value from the database by locating the key string provided.  If the
+  # key is not found, returns `ifnone`. If `ifnone` is not given, raises
+  # IndexError.
+  #
+  def fetch: (*String) -> untyped
+
+  # Returns true if the database contains the specified key, false otherwise.
+  #
+  def has_key?: (String) -> bool
+
+  # Returns true if the database contains the specified string value, false
+  # otherwise.
+  #
+  def has_value?: (untyped) -> bool
+
+  # Returns true if the database contains the specified key, false otherwise.
+  #
+  def include?: (String) -> bool
+
+  def index: (untyped) -> (String | NilClass)
+
+  # Returns a Hash (not a DBM database) created by using each value in the
+  # database as a key, with the corresponding key as its value.
+  #
+  def invert: () -> Hash[untyped, String]
+
+  # Returns the key for the specified value.
+  #
+  def key: (untyped) -> (String | NilClass)
+
+  # Returns true if the database contains the specified key, false otherwise.
+  #
+  def key?: (untyped) -> bool
+
+  # Returns an array of all the string keys in the database.
+  #
+  def keys: () -> Array[String]
+
+  # Returns the number of entries in the database.
+  #
+  def length: () -> Integer
+
+  # Returns true if the database contains the specified key, false otherwise.
+  #
+  def member?: (untyped) -> bool
+
+  # Converts the contents of the database to an in-memory Hash, then calls
+  # Hash#reject with the specified code block, returning a new Hash.
+  #
+  def reject: () -> Hash[untyped, untyped]
+
+  # Deletes all entries for which the code block returns true. Returns self.
+  #
+  def reject!: () { (String, untyped) -> untyped } -> self
+
+  # Replaces the contents of the database with the contents of the specified
+  # object. Takes any object which implements the each_pair method, including Hash
+  # and DBM objects.
+  #
+  def replace: (untyped) -> ::DBM
+
+  # Returns a new array consisting of the [key, value] pairs for which the code
+  # block returns true.
+  #
+  def select: () { () -> untyped } -> Array[untyped]
+
+  # Removes a [key, value] pair from the database, and returns it. If the database
+  # is empty, returns nil. The order in which values are removed/returned is not
+  # guaranteed.
+  #
+  def shift: () -> Array[untyped]
+
+  # Returns the number of entries in the database.
+  #
+  def size: () -> Integer
+
+  # Stores the specified string value in the database, indexed via the string key
+  # provided.
+  #
+  def store: (String, untyped) -> String
+
+  # Converts the contents of the database to an array of [key, value] arrays, and
+  # returns it.
+  #
+  def to_a: () -> Array[untyped]
+
+  # Converts the contents of the database to an in-memory Hash object, and returns
+  # it.
+  #
+  def to_hash: () -> Hash[String, untyped]
+
+  # Updates the database with multiple values from the specified object. Takes any
+  # object which implements the each_pair method, including Hash and DBM objects.
+  #
+  def update: (untyped) -> ::DBM
+
+  # Returns true if the database contains the specified string value, false
+  # otherwise.
+  #
+  def value?: (untyped) -> bool
+
+  # Returns an array of all the string values in the database.
+  #
+  def values: () -> Array[untyped]
+
+  # Returns an array containing the values associated with the given keys.
+  #
+  def values_at: (*String) -> Array[untyped]
+
+  private
+
+  # Open a dbm database with the specified name, which can include a directory
+  # path. Any file extensions needed will be supplied automatically by the dbm
+  # library. For example, Berkeley DB appends '.db', and GNU gdbm uses two
+  # physical files with extensions '.dir' and '.pag'.
+  #
+  # The mode should be an integer, as for Unix chmod.
+  #
+  # Flags should be one of READER, WRITER, WRCREAT or NEWDB.
+  #
+  def initialize: (*untyped) -> self
+end
+
+# Indicates that dbm_open() should open the database in read/write mode, create
+# it if it does not already exist, and delete all contents if it does already
+# exist.
+#
+DBM::NEWDB: Integer
+
+# Indicates that dbm_open() should open the database in read-only mode
+#
+#
+DBM::READER: Integer
+
+# Identifies ndbm library version.
+#
+# Examples:
+#
+# *   "ndbm (4.3BSD)"
+# *   "Berkeley DB 4.8.30: (April  9, 2010)"
+# *   "Berkeley DB (unknown)" (4.4BSD, maybe)
+# *   "GDBM version 1.8.3. 10/15/2002 (built Jul  1 2011 12:32:45)"
+# *   "QDBM 1.8.78"
+#
+#
+DBM::VERSION: String
+
+# Indicates that dbm_open() should open the database in read/write mode, and
+# create it if it does not already exist
+#
+DBM::WRCREAT: Integer
+
+# Indicates that dbm_open() should open the database in read/write mode
+#
+#
+DBM::WRITER: Integer

data/stdlib/find/{find.rbs → 0/find.rbs}

@@ -27,8 +27,8 @@ module Find
   #
   # See the `Find` module documentation for an example.
   #
-  def self?.find: (*String | _ToPath paths, ?ignore_error: bool) -> Enumerator[String, nil]
-                | (*String | _ToPath paths, ?ignore_error: bool) { (String arg0) -> void } -> nil
+  def self?.find: (*String | _ToPath paths, ?ignore_error: boolish) -> Enumerator[String, nil]
+                | (*String | _ToPath paths, ?ignore_error: boolish) { (String) -> void } -> nil
 
   # Skips the current file or directory, restarting the loop with the next entry.
   # If the current file is a directory, that directory will not be recursively

data/stdlib/logger/{log_device.rbs → 0/log_device.rbs}

@@ -24,7 +24,7 @@ class Logger
 
     def create_logfile: (String filename) -> File
 
-    def initialize: (?untyped logdev, ?binmode: bool, ?shift_period_suffix: String, ?shift_size: Integer, ?shift_age: Numeric | String) -> void
+    def initialize: (?untyped logdev, ?binmode: boolish, ?shift_period_suffix: String, ?shift_size: Integer, ?shift_age: Numeric | String) -> void
 
     def lock_shift_log: () { () -> untyped } -> untyped
 

data/stdlib/logger/{logger.rbs → 0/logger.rbs}

@@ -495,7 +495,7 @@ class Logger
   #
   # Create an instance.
   #
-  def initialize: (logdev logdev, ?Numeric | String shift_age, ?Integer shift_size, ?shift_period_suffix: String, ?binmode: bool, ?datetime_format: String, ?formatter: _Formatter, ?progname: String, ?level: Integer) -> void
+  def initialize: (logdev logdev, ?Numeric | String shift_age, ?Integer shift_size, ?shift_period_suffix: String, ?binmode: boolish, ?datetime_format: String, ?formatter: _Formatter, ?progname: String, ?level: Integer) -> void
 end
 
 Logger::ProgName: String

data/stdlib/pathname/{pathname.rbs → 0/pathname.rbs}

@@ -324,9 +324,9 @@ class Pathname
                  ?external_encoding: encoding,
                  ?internal_encoding: encoding,
                  ?encoding: encoding,
-                 ?textmode: bool,
-                 ?binmode: bool,
-                 ?autoclose: bool,
+                 ?textmode: boolish,
+                 ?binmode: boolish,
+                 ?autoclose: boolish,
 
                  # From String#encode
                  ?invalid: :replace ?,
@@ -373,7 +373,7 @@ class Pathname
   # Note that the results never contain the entries `.` and `..` in the directory
   # because they are not children.
   #
-  def children: (?bool with_directory) -> untyped
+  def children: (?boolish with_directory) -> untyped
 
   # Changes file permissions.
   #
@@ -397,7 +397,7 @@ class Pathname
   #
   # See Pathname#realpath.
   #
-  def cleanpath: (?bool consider_symlink) -> Pathname
+  def cleanpath: (?boolish consider_symlink) -> Pathname
 
   # Returns the last change time, using directory information, not the file
   # itself.
@@ -485,8 +485,8 @@ class Pathname
   #
   # See Pathname#children
   #
-  def each_child: (?bool with_directory) { (Pathname) -> void } -> Array[Pathname]
-                | (?bool with_directory) -> Enumerator[Pathname, Array[Pathname]]
+  def each_child: (?boolish with_directory) { (Pathname) -> void } -> Array[Pathname]
+                | (?boolish with_directory) -> Enumerator[Pathname, Array[Pathname]]
 
   # Iterates over the entries (files and subdirectories) in the directory,
   # yielding a Pathname object for each entry.
@@ -517,11 +517,11 @@ class Pathname
                   ?external_encoding: encoding,
                   ?internal_encoding: encoding,
                   ?encoding: encoding,
-                  ?textmode: bool,
-                  ?binmode: bool,
-                  ?autoclose: bool,
+                  ?textmode: boolish,
+                  ?binmode: boolish,
+                  ?autoclose: boolish,
                   # getline_args
-                  ?chomp: bool,
+                  ?chomp: boolish,
                  ) { (String) -> untyped } -> nil
                | (Integer limit,
                   # open_args
@@ -530,11 +530,11 @@ class Pathname
                   ?external_encoding: encoding,
                   ?internal_encoding: encoding,
                   ?encoding: encoding,
-                  ?textmode: bool,
-                  ?binmode: bool,
-                  ?autoclose: bool,
+                  ?textmode: boolish,
+                  ?binmode: boolish,
+                  ?autoclose: boolish,
                   # getline_args
-                  ?chomp: bool,
+                  ?chomp: boolish,
                  ) { (String) -> untyped } -> nil
                | (?String sep, ?Integer limit,
                   # open_args
@@ -543,11 +543,11 @@ class Pathname
                   ?external_encoding: encoding,
                   ?internal_encoding: encoding,
                   ?encoding: encoding,
-                  ?textmode: bool,
-                  ?binmode: bool,
-                  ?autoclose: bool,
+                  ?textmode: boolish,
+                  ?binmode: boolish,
+                  ?autoclose: boolish,
                   # getline_args
-                  ?chomp: bool,
+                  ?chomp: boolish,
                  ) -> Enumerator[String, nil]
                | (Integer limit,
                   # open_args
@@ -556,11 +556,11 @@ class Pathname
                   ?external_encoding: encoding,
                   ?internal_encoding: encoding,
                   ?encoding: encoding,
-                  ?textmode: bool,
-                  ?binmode: bool,
-                  ?autoclose: bool,
+                  ?textmode: boolish,
+                  ?binmode: boolish,
+                  ?autoclose: boolish,
                   # getline_args
-                  ?chomp: bool,
+                  ?chomp: boolish,
                  ) -> Enumerator[String, nil]
 
   # Tests the file is empty.
@@ -643,8 +643,8 @@ class Pathname
   #
   # See Find.find
   #
-  def find: (?ignore_error: bool) { (Pathname) -> untyped } -> nil
-          | (?ignore_error: bool) -> Enumerator[Pathname, nil]
+  def find: (?ignore_error: boolish) { (Pathname) -> untyped } -> nil
+          | (?ignore_error: boolish) -> Enumerator[Pathname, nil]
 
   # Return `true` if the receiver matches the given pattern.
   #
@@ -789,9 +789,9 @@ class Pathname
              ?external_encoding: encoding,
              ?internal_encoding: encoding,
              ?encoding: encoding,
-             ?textmode: bool,
-             ?binmode: bool,
-             ?autoclose: bool,
+             ?textmode: boolish,
+             ?binmode: boolish,
+             ?autoclose: boolish,
             ) -> String
 
   # See FileTest.readable?.
@@ -813,11 +813,11 @@ class Pathname
                   ?external_encoding: encoding,
                   ?internal_encoding: encoding,
                   ?encoding: encoding,
-                  ?textmode: bool,
-                  ?binmode: bool,
-                  ?autoclose: bool,
+                  ?textmode: boolish,
+                  ?binmode: boolish,
+                  ?autoclose: boolish,
                   # getline_args
-                  ?chomp: bool,
+                  ?chomp: boolish,
                  ) -> Array[String]
                | (Integer limit,
                   # open_args
@@ -826,11 +826,11 @@ class Pathname
                   ?external_encoding: encoding,
                   ?internal_encoding: encoding,
                   ?encoding: encoding,
-                  ?textmode: bool,
-                  ?binmode: bool,
-                  ?autoclose: bool,
+                  ?textmode: boolish,
+                  ?binmode: boolish,
+                  ?autoclose: boolish,
                   # getline_args
-                  ?chomp: bool,
+                  ?chomp: boolish,
                  ) -> Array[String]
 
   # Read symbolic link.
@@ -1033,9 +1033,9 @@ class Pathname
               ?external_encoding: encoding,
               ?internal_encoding: encoding,
               ?encoding: encoding,
-              ?textmode: bool,
-              ?binmode: bool,
-              ?autoclose: bool,
+              ?textmode: boolish,
+              ?binmode: boolish,
+              ?autoclose: boolish,
              ) -> Integer
 
   # See FileTest.zero?.