rbs 0.14.0 → 0.15.0

data/stdlib/builtin/object.rbs

@@ -631,7 +631,7 @@ class Object < BasicObject
   # When the method name parameter is given as a string, the string is converted
   # to a symbol.
   #
-  def respond_to?: (name name, ?bool include_all) -> bool
+  def respond_to?: (name name, ?boolish include_all) -> bool
 
   # 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

data/stdlib/builtin/random.rbs

@@ -246,7 +246,7 @@ module Random::Formatter
   #
   # See RFC 3548 for the definition of URL-safe base64.
   #
-  def urlsafe_base64: (?Integer? n, ?bool padding) -> String
+  def urlsafe_base64: (?Integer? n, ?boolish padding) -> String
 
   # SecureRandom.uuid generates a random v4 UUID (Universally Unique IDentifier).
   #

data/stdlib/builtin/range.rbs

@@ -101,7 +101,7 @@ class Range[out Elem] < Object
   # ```
   def begin: () -> Elem
 
-  def bsearch: [U] () { (Elem arg0) -> bool } -> U?
+  def bsearch: [U] () { (Elem) -> boolish } -> U?
 
   def cover?: (untyped obj) -> bool
 
@@ -144,7 +144,7 @@ class Range[out Elem] < Object
 
   def `include?`: (untyped obj) -> bool
 
-  def initialize: (Elem from, Elem to, ?bool exclude_end) -> void
+  def initialize: (Elem from, Elem to, ?boolish exclude_end) -> void
 
   # Convert this range object to a printable form (using `inspect` to
   # convert the begin and end objects).

data/stdlib/builtin/string.rbs

@@ -317,7 +317,7 @@ class String
   #     "foo".casecmp?(2)   #=> nil
   #     "\u{e4 f6 fc}".encode("ISO-8859-1").casecmp?("\u{c4 d6 dc}")   #=> nil
   #
-  def casecmp?: (untyped other) -> bool
+  def casecmp?: (untyped other) -> bool?
 
   # Centers `str` in `width`.  If `width` is greater than the length of `str`,
   # returns a new String of length `width` with `str` centered and padded with
@@ -698,8 +698,8 @@ class String
   #     #   "o\nwor"
   #     #   "d"
   #
-  def each_line: (?string separator, ?chomp: bool) { (String line) -> void } -> self
-               | (?string separator, ?chomp: bool) -> Enumerator[String, self]
+  def each_line: (?string separator, ?chomp: boolish) { (String line) -> void } -> self
+               | (?string separator, ?chomp: boolish) -> Enumerator[String, self]
 
   # Returns `true` if *str* has a length of zero.
   #
@@ -948,7 +948,7 @@ class String
   # If a block is given, which is a deprecated form, works the same as
   # `each_line`.
   #
-  def lines: (?string separator, ?chomp: bool) -> Array[String]
+  def lines: (?string separator, ?chomp: boolish) -> Array[String]
 
   # If *integer* is greater than the length of *str*, returns a new String of
   # length *integer* with *str* left justified and padded with *padstr*;
@@ -1861,8 +1861,8 @@ class String
   #     "25".upto("5").to_a   #=> []
   #     "07".upto("11").to_a  #=> ["07", "08", "09", "10", "11"]
   #
-  def upto: (string other_str, ?bool exclusive) -> Enumerator[String, self]
-          | (string other_str, ?bool exclusive) { (String s) -> void } -> self
+  def upto: (string other_str, ?boolish exclusive) -> Enumerator[String, self]
+          | (string other_str, ?boolish exclusive) { (String s) -> void } -> self
 
   # Returns true for a string which is encoded correctly.
   #

data/stdlib/builtin/string_io.rbs

@@ -63,8 +63,8 @@ class StringIO
 
   # See IO#each.
   #
-  def each: (?String sep, ?Integer limit, ?chomp: bool) { (String arg0) -> untyped } -> self
-          | (?String sep, ?Integer limit, ?chomp: bool) -> ::Enumerator[String, self]
+  def each: (?String sep, ?Integer limit, ?chomp: boolish) { (String) -> untyped } -> self
+          | (?String sep, ?Integer limit, ?chomp: boolish) -> ::Enumerator[String, self]
 
   # See IO#each_byte.
   #
@@ -112,7 +112,7 @@ class StringIO
 
   # See IO#gets.
   #
-  def gets: (?String sep, ?Integer limit, ?chomp: bool) -> String?
+  def gets: (?String sep, ?Integer limit, ?chomp: boolish) -> String?
 
   # Returns the Encoding of the internal string if conversion is specified.
   # Otherwise returns `nil`.
@@ -177,7 +177,7 @@ class StringIO
 
   # See IO#readlines.
   #
-  def readlines: (?String sep, ?Integer limit, ?chomp: bool) -> ::Array[String]
+  def readlines: (?String sep, ?Integer limit, ?chomp: boolish) -> ::Array[String]
 
   def readpartial: (Integer maxlen) -> String
                  | (Integer maxlen, ?String outbuf) -> String
@@ -222,7 +222,7 @@ class StringIO
 
   # Returns the argument unchanged.  Just for compatibility to IO.
   #
-  def sync=: (bool arg0) -> bool
+  def sync=: (boolish) -> bool
 
   def sysread: (Integer maxlen, String outbuf) -> String
 
@@ -269,8 +269,8 @@ class StringIO
 
   # 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]
+  def each_line: (?String sep, ?Integer limit, ?chomp: boolish) { (String) -> untyped } -> self
+               | (?String sep, ?Integer limit, ?chomp: boolish) -> ::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.

data/stdlib/builtin/struct.rbs

@@ -31,7 +31,7 @@ class Struct[Elem] < Object
 
   type attribute_name = Symbol | String
 
-  def initialize: (attribute_name, *attribute_name, ?keyword_init: bool) ?{ () -> void } -> void
+  def initialize: (attribute_name, *attribute_name, ?keyword_init: boolish) ?{ () -> void } -> void
 
   def each: () { (Elem) -> untyped } -> untyped
 

data/stdlib/builtin/symbol.rbs

@@ -109,7 +109,7 @@ class 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
+  def casecmp?: (untyped other) -> bool?
 
   # Same as `sym.to_s.downcase.intern`.
   #

data/stdlib/builtin/thread.rbs

@@ -240,7 +240,7 @@ class Thread < Object
   # There is also a class level method to set this for all threads, see
   # [::abort\_on\_exception=](Thread.downloaded.ruby_doc#method-c-abort_on_exception-3D)
   # .
-  def abort_on_exception=: (bool abort_on_exception) -> untyped
+  def abort_on_exception=: (boolish abort_on_exception) -> untyped
 
   # Adds *proc* as a handler for tracing.
   #
@@ -424,7 +424,7 @@ class Thread < Object
   # There is also a class level method to set this for all new threads, see
   # [::report\_on\_exception=](Thread.downloaded.ruby_doc#method-c-report_on_exception-3D)
   # .
-  def report_on_exception=: (bool report_on_exception) -> untyped
+  def report_on_exception=: (boolish report_on_exception) -> untyped
 
   # Wakes up `thr`, making it eligible for scheduling.
   #
@@ -1049,7 +1049,7 @@ class Thread::Queue < Object
   #
   # Also aliased as: [deq](Queue.downloaded.ruby_doc#method-i-deq),
   # [shift](Queue.downloaded.ruby_doc#method-i-shift)
-  def pop: (?bool non_block) -> untyped
+  def pop: (?boolish non_block) -> untyped
 
   # Pushes the given `object` to the queue.
   #
@@ -1096,7 +1096,7 @@ class Thread::SizedQueue < Thread::Queue
   #
   # Also aliased as: [enq](SizedQueue.downloaded.ruby_doc#method-i-enq),
   # [\<\<](SizedQueue.downloaded.ruby_doc#method-i-3C-3C)
-  def push: (untyped obj, ?bool non_block) -> void
+  def push: (untyped obj, ?boolish non_block) -> void
 end
 
 ConditionVariable: singleton(Thread::ConditionVariable)

data/stdlib/builtin/true_class.rbs

@@ -42,5 +42,5 @@ class TrueClass
   #
   #     or
   #
-  def |: (bool obj) -> bool
+  def |: (boolish obj) -> bool
 end

data/stdlib/coverage/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

@@ -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

@@ -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

@@ -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/find/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

@@ -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

@@ -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

@@ -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?.

data/stdlib/pstore/pstore.rbs

@@ -0,0 +1,287 @@
+# PStore implements a file based persistence mechanism based on a Hash.  User
+# code can store hierarchies of Ruby objects (values) into the data store file
+# by name (keys).  An object hierarchy may be just a single object.  User code
+# may later read values back from the data store or even update data, as needed.
+#
+# The transactional behavior ensures that any changes succeed or fail together.
+# This can be used to ensure that the data store is not left in a transitory
+# state, where some values were updated but others were not.
+#
+# Behind the scenes, Ruby objects are stored to the data store file with
+# Marshal.  That carries the usual limitations.  Proc objects cannot be
+# marshalled, for example.
+#
+# ## Usage example:
+#
+#     require "pstore"
+#
+#     # a mock wiki object...
+#     class WikiPage
+#       def initialize( page_name, author, contents )
+#         @page_name = page_name
+#         @revisions = Array.new
+#
+#         add_revision(author, contents)
+#       end
+#
+#       attr_reader :page_name
+#
+#       def add_revision( author, contents )
+#         @revisions << { :created  => Time.now,
+#                         :author   => author,
+#                         :contents => contents }
+#       end
+#
+#       def wiki_page_references
+#         [@page_name] + @revisions.last[:contents].scan(/\b(?:[A-Z]+[a-z]+){2,}/)
+#       end
+#
+#       # ...
+#     end
+#
+#     # create a new page...
+#     home_page = WikiPage.new( "HomePage", "James Edward Gray II",
+#                               "A page about the JoysOfDocumentation..." )
+#
+#     # then we want to update page data and the index together, or not at all...
+#     wiki = PStore.new("wiki_pages.pstore")
+#     wiki.transaction do  # begin transaction; do all of this or none of it
+#       # store page...
+#       wiki[home_page.page_name] = home_page
+#       # ensure that an index has been created...
+#       wiki[:wiki_index] ||= Array.new
+#       # update wiki index...
+#       wiki[:wiki_index].push(*home_page.wiki_page_references)
+#     end                   # commit changes to wiki data store file
+#
+#     ### Some time later... ###
+#
+#     # read wiki data...
+#     wiki.transaction(true) do  # begin read-only transaction, no changes allowed
+#       wiki.roots.each do |data_root_name|
+#         p data_root_name
+#         p wiki[data_root_name]
+#       end
+#     end
+#
+# ## Transaction modes
+#
+# By default, file integrity is only ensured as long as the operating system
+# (and the underlying hardware) doesn't raise any unexpected I/O errors. If an
+# I/O error occurs while PStore is writing to its file, then the file will
+# become corrupted.
+#
+# You can prevent this by setting *pstore.ultra_safe = true*. However, this
+# results in a minor performance loss, and only works on platforms that support
+# atomic file renames. Please consult the documentation for `ultra_safe` for
+# details.
+#
+# Needless to say, if you're storing valuable data with PStore, then you should
+# backup the PStore files from time to time.
+#
+class PStore
+  public
+
+  # Retrieves a value from the PStore file data, by *name*.  The hierarchy of Ruby
+  # objects stored under that root *name* will be returned.
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def []: (untyped name) -> untyped
+
+  # Stores an individual Ruby object or a hierarchy of Ruby objects in the data
+  # store file under the root *name*.  Assigning to a *name* already in the data
+  # store clobbers the old data.
+  #
+  # ## Example:
+  #
+  #     require "pstore"
+  #
+  #     store = PStore.new("data_file.pstore")
+  #     store.transaction do  # begin transaction
+  #       # load some data into the store...
+  #       store[:single_object] = "My data..."
+  #       store[:obj_hierarchy] = { "Kev Jackson" => ["rational.rb", "pstore.rb"],
+  #                                 "James Gray"  => ["erb.rb", "pstore.rb"] }
+  #     end                   # commit changes to data store file
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction and it cannot
+  # be read-only.  It will raise PStore::Error if called at any other time.
+  #
+  def []=: (untyped name, untyped value) -> untyped
+
+  # Ends the current PStore#transaction, discarding any changes to the data store.
+  #
+  # ## Example:
+  #
+  #     require "pstore"
+  #
+  #     store = PStore.new("data_file.pstore")
+  #     store.transaction do  # begin transaction
+  #       store[:one] = 1     # this change is not applied, see below...
+  #       store[:two] = 2     # this change is not applied, see below...
+  #
+  #       store.abort         # end transaction here, discard all changes
+  #
+  #       store[:three] = 3   # this change is never reached
+  #     end
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def abort: () -> untyped
+
+  # Ends the current PStore#transaction, committing any changes to the data store
+  # immediately.
+  #
+  # ## Example:
+  #
+  #     require "pstore"
+  #
+  #     store = PStore.new("data_file.pstore")
+  #     store.transaction do  # begin transaction
+  #       # load some data into the store...
+  #       store[:one] = 1
+  #       store[:two] = 2
+  #
+  #       store.commit        # end transaction here, committing changes
+  #
+  #       store[:three] = 3   # this change is never reached
+  #     end
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def commit: () -> nil
+
+  # Removes an object hierarchy from the data store, by *name*.
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction and it cannot
+  # be read-only.  It will raise PStore::Error if called at any other time.
+  #
+  def delete: (untyped name) -> untyped
+
+  # This method is just like PStore#[], save that you may also provide a *default*
+  # value for the object.  In the event the specified *name* is not found in the
+  # data store, your *default* will be returned instead.  If you do not specify a
+  # default, PStore::Error will be raised if the object is not found.
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def fetch: (untyped name, ?untyped default) -> untyped
+
+  # Returns the path to the data store file.
+  #
+  def path: () -> untyped
+
+  # Returns true if the supplied *name* is currently in the data store.
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def root?: (untyped name) -> bool
+
+  # Returns the names of all object hierarchies currently in the store.
+  #
+  # **WARNING**:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def roots: () -> Array[untyped]
+
+  # Opens a new transaction for the data store.  Code executed inside a block
+  # passed to this method may read and write data to and from the data store file.
+  #
+  # At the end of the block, changes are committed to the data store
+  # automatically.  You may exit the transaction early with a call to either
+  # PStore#commit or PStore#abort.  See those methods for details about how
+  # changes are handled.  Raising an uncaught Exception in the block is equivalent
+  # to calling PStore#abort.
+  #
+  # If *read_only* is set to `true`, you will only be allowed to read from the
+  # data store during the transaction and any attempts to change the data will
+  # raise a PStore::Error.
+  #
+  # Note that PStore does not support nested transactions.
+  #
+  def transaction: (?untyped read_only) -> untyped
+
+  # Whether PStore should do its best to prevent file corruptions, even when under
+  # unlikely-to-occur error conditions such as out-of-space conditions and other
+  # unusual OS filesystem errors. Setting this flag comes at the price in the form
+  # of a performance loss.
+  #
+  # This flag only has effect on platforms on which file renames are atomic (e.g.
+  # all POSIX platforms: Linux, MacOS X, FreeBSD, etc). The default value is
+  # false.
+  #
+  def ultra_safe: () -> untyped
+
+  def ultra_safe=: (untyped) -> untyped
+
+  private
+
+  def dump: (untyped table) -> untyped
+
+  def empty_marshal_checksum: () -> untyped
+
+  def empty_marshal_data: () -> untyped
+
+  # Raises PStore::Error if the calling code is not in a PStore#transaction.
+  #
+  def in_transaction: () -> untyped
+
+  # Raises PStore::Error if the calling code is not in a PStore#transaction or if
+  # the code is in a read-only PStore#transaction.
+  #
+  def in_transaction_wr: () -> untyped
+
+  # To construct a PStore object, pass in the *file* path where you would like the
+  # data to be stored.
+  #
+  # PStore objects are always reentrant. But if *thread_safe* is set to true, then
+  # it will become thread-safe at the cost of a minor performance hit.
+  #
+  def initialize: (untyped file, ?boolish thread_safe) -> untyped
+
+  def load: (untyped content) -> untyped
+
+  # Load the given PStore file. If `read_only` is true, the unmarshalled Hash will
+  # be returned. If `read_only` is false, a 3-tuple will be returned: the
+  # unmarshalled Hash, a checksum of the data, and the size of the data.
+  #
+  def load_data: (untyped file, untyped read_only) -> untyped
+
+  def on_windows?: () -> bool
+
+  # Open the specified filename (either in read-only mode or in read-write mode)
+  # and lock it for reading or writing.
+  #
+  # The opened File object will be returned. If *read_only* is true, and the file
+  # does not exist, then nil will be returned.
+  #
+  # All exceptions are propagated.
+  #
+  def open_and_lock_file: (untyped filename, untyped read_only) -> untyped
+
+  def save_data: (untyped original_checksum, untyped original_file_size, untyped file) -> untyped
+
+  def save_data_with_atomic_file_rename_strategy: (untyped data, untyped file) -> untyped
+
+  def save_data_with_fast_strategy: (untyped data, untyped file) -> untyped
+end
+
+PStore::EMPTY_MARSHAL_CHECKSUM: String
+
+PStore::EMPTY_MARSHAL_DATA: String
+
+PStore::EMPTY_STRING: String
+
+PStore::RDWR_ACCESS: Hash[untyped, untyped]
+
+PStore::RD_ACCESS: Hash[untyped, untyped]
+
+PStore::VERSION: String
+
+PStore::WR_ACCESS: Hash[untyped, untyped]