rbs 0.12.1 → 0.15.0

data/stdlib/builtin/thread_group.rbs

@@ -1,11 +1,11 @@
 # [ThreadGroup](ThreadGroup) provides a means of
 # keeping track of a number of threads as a group.
-# 
+#
 # A given [Thread](https://ruby-doc.org/core-2.6.3/Thread.html) object can
 # only belong to one [ThreadGroup](ThreadGroup) at a
 # time; adding a thread to a new group will remove it from any previous
 # group.
-# 
+#
 # Newly created threads belong to the same group as the thread from which
 # they were created.
 class ThreadGroup < Object

data/stdlib/builtin/true_class.rbs

@@ -1,14 +1,14 @@
 # The global value `true` is the only instance of class TrueClass and represents
 # a logically true value in boolean expressions. The class provides operators
 # allowing `true` to be used in logical expressions.
-# 
+#
 class TrueClass
   public
 
   def !: () -> bool
 
   # And---Returns `false` if *obj* is `nil` or `false`, `true` otherwise.
-  # 
+  #
   def &: (nil) -> false
        | (false) -> false
        | (untyped obj) -> bool
@@ -16,12 +16,12 @@ class TrueClass
   # Case Equality -- For class Object, effectively the same as calling `#==`, but
   # typically overridden by descendants to provide meaningful semantics in `case`
   # statements.
-  # 
+  #
   def ===: (true) -> true
          | (untyped obj) -> bool
 
   # Exclusive Or---Returns `true` if *obj* is `nil` or `false`, `false` otherwise.
-  # 
+  #
   def ^: (nil) -> true
        | (false) -> true
        | (untyped obj) -> bool
@@ -29,18 +29,18 @@ class TrueClass
   alias inspect to_s
 
   # The string representation of `true` is "true".
-  # 
+  #
   def to_s: () -> "true"
 
   # Or---Returns `true`. As *obj* is an argument to a method call, it is always
   # evaluated; there is no short-circuit evaluation in this case.
-  # 
+  #
   #     true |  puts("or")
   #     true || puts("logical or")
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     or
-  # 
-  def |: (bool obj) -> bool
+  #
+  def |: (boolish obj) -> bool
 end

data/stdlib/builtin/warning.rbs

@@ -3,7 +3,7 @@
 # module extends itself, making `Warning.warn` available.
 # [\#warn](Warning#method-i-warn) is called for all
 # warnings issued by Ruby. By default, warnings are printed to $stderr.
-# 
+#
 # By overriding [\#warn](Warning#method-i-warn), you
 # can change how warnings are handled by Ruby, either filtering some
 # warnings, and/or outputting warnings somewhere other than $stderr. When

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.
   #
@@ -318,7 +318,7 @@ class Date
   #
   def self.ordinal: (?Integer year, ?Integer yday, ?Integer start) -> Date
 
-  # Parses the given representation of date and time, and creates a date object. 
+  # Parses the given representation of date and time, and creates a date object.
   # This method does not function as a validator.
   #
   # If the optional second argument is true and the detected year is in the range
@@ -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.
@@ -448,7 +448,7 @@ class Date
   #
   def +: (Integer | Rational other) -> Date
 
-  # Returns the difference between the two dates if the other is a date object. 
+  # Returns the difference between the two dates if the other is a date object.
   # If the other is a numeric value, returns a date object pointing `other` days
   # before self.  If the other is a fractional number, assumes its precision is at
   # most nanosecond.

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

@@ -1,12 +1,12 @@
 # The `Find` module supports the top-down traversal of a set of file paths.
-# 
+#
 # For example, to total the size of all files under your home directory,
 # ignoring anything in a "dot" directory (e.g. $HOME/.ssh):
-# 
+#
 #     require 'find'
-# 
+#
 #     total_size = 0
-# 
+#
 #     Find.find(ENV["HOME"]) do |path|
 #       if FileTest.directory?(path)
 #         if File.basename(path).start_with?('.')
@@ -18,23 +18,23 @@
 #         total_size += FileTest.size(path)
 #       end
 #     end
-# 
+#
 module Find
   # Calls the associated block with the name of every file and directory listed as
   # arguments, then recursively on their subdirectories, and so on.
-  # 
+  #
   # Returns an enumerator if no block is given.
-  # 
+  #
   # 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
   # entered. Meaningful only within the block associated with Find::find.
-  # 
+  #
   # See the `Find` module documentation for an example.
-  # 
+  #
   def self?.prune: () -> void
 end

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?.
@@ -1077,6 +1077,8 @@ class Pathname
 end
 
 module Kernel
+  private
+
   # Creates a new Pathname object from the given string, `path`, and returns
   # pathname object.
   #

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]