rbs 0.14.0 → 0.18.1

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

@@ -137,7 +137,7 @@ class Prime
   class PseudoPrimeGenerator
     def initialize: (?Integer?) -> void
 
-    include Enumerable[Integer, void]
+    include Enumerable[Integer]
 
     attr_accessor upper_bound (): Integer?
 

data/stdlib/pstore/0/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]

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

@@ -66,7 +66,7 @@ module PTY
   # :   If `true` and the process identified by `pid` is no longer alive a
   #     PTY::ChildExited is raised.
   #
-  def self.check: (Integer pid, ?bool raise) -> Process::Status?
+  def self.check: (Integer pid, ?boolish raise) -> Process::Status?
 
   alias self.getpty self.spawn
 

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

@@ -51,8 +51,8 @@ class Set[A]
   #     Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
   #     Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>
   #
-  def initialize: (_Each[A, untyped]) -> untyped
-                | [X] (_Each[X, untyped]) { (X) -> A } -> untyped
+  def initialize: (_Each[A]) -> untyped
+                | [X] (_Each[X]) { (X) -> A } -> untyped
                 | (?nil) -> untyped
 
   # Creates a new set containing the given objects.
@@ -69,7 +69,7 @@ class Set[A]
   #     Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
   #     Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>
   #
-  def &: (_Each[A, untyped]) -> self
+  def &: (_Each[A]) -> self
 
   alias intersection &
 
@@ -79,7 +79,7 @@ class Set[A]
   #     Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
   #     Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>
   #
-  def |: (_Each[A, untyped]) -> self
+  def |: (_Each[A]) -> self
 
   alias union |
 
@@ -91,7 +91,7 @@ class Set[A]
   #     Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
   #     Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>
   #
-  def -: (_Each[A, untyped]) -> self
+  def -: (_Each[A]) -> self
 
   alias difference -
 
@@ -133,7 +133,7 @@ class Set[A]
   #     Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
   #     Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>
   #
-  def ^: (_Each[A, untyped]) -> self
+  def ^: (_Each[A]) -> self
 
   # Classifies the set by the return value of the given block and returns a hash
   # of {value => set of elements} pairs.  The block is called once for each
@@ -248,7 +248,7 @@ class Set[A]
   # Merges the elements of the given enumerable object to the set and returns
   # self.
   #
-  def merge: (_Each[A, untyped]) -> self
+  def merge: (_Each[A]) -> self
 
   # Returns true if the set is a subset of the given set.
   #
@@ -271,7 +271,7 @@ class Set[A]
   #     set.replace([1, 2])               #=> #<Set: {1, 2}>
   #     set                               #=> #<Set: {1, 2}>
   #
-  def replace: (_Each[A, untyped]) -> self
+  def replace: (_Each[A]) -> self
 
   # Resets the internal state after modification to existing elements and returns
   # self.
@@ -288,7 +288,7 @@ class Set[A]
   # Deletes every element that appears in the given enumerable object and returns
   # self.
   #
-  def subtract: (_Each[A, untyped]) -> self
+  def subtract: (_Each[A]) -> self
 
   # Converts the set to an array.  The order of elements is uncertain.
   #
@@ -297,5 +297,5 @@ class Set[A]
   #
   def to_a: () -> Array[A]
 
-  include Enumerable[A, self]
+  include Enumerable[A]
 end

data/stdlib/singleton/0/singleton.rbs

@@ -0,0 +1,111 @@
+# The Singleton module implements the Singleton pattern.
+#
+# ## Usage
+#
+# To use Singleton, include the module in your class.
+#
+#     class Klass
+#        include Singleton
+#        # ...
+#     end
+#
+# This ensures that only one instance of Klass can be created.
+#
+#     a,b = Klass.instance, Klass.instance
+#
+#     a == b
+#     # => true
+#
+#     Klass.new
+#     # => NoMethodError - new is private ...
+#
+# The instance is created at upon the first call of Klass.instance().
+#
+#     class OtherKlass
+#       include Singleton
+#       # ...
+#     end
+#
+#     ObjectSpace.each_object(OtherKlass){}
+#     # => 0
+#
+#     OtherKlass.instance
+#     ObjectSpace.each_object(OtherKlass){}
+#     # => 1
+#
+# This behavior is preserved under inheritance and cloning.
+#
+# ## Implementation
+#
+# This above is achieved by:
+#
+# *   Making Klass.new and Klass.allocate private.
+#
+# *   Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the
+#     Singleton properties are kept when inherited and cloned.
+#
+# *   Providing the Klass.instance() method that returns the same object each
+#     time it is called.
+#
+# *   Overriding Klass._load(str) to call Klass.instance().
+#
+# *   Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent
+#     cloning or duping.
+#
+#
+# ## Singleton and Marshal
+#
+# By default Singleton's #_dump(depth) returns the empty string. Marshalling by
+# default will strip state information, e.g. instance variables from the
+# instance. Classes using Singleton can provide custom _load(str) and
+# _dump(depth) methods to retain some of the previous state of the instance.
+#
+#     require 'singleton'
+#
+#     class Example
+#       include Singleton
+#       attr_accessor :keep, :strip
+#       def _dump(depth)
+#         # this strips the @strip information from the instance
+#         Marshal.dump(@keep, depth)
+#       end
+#
+#       def self._load(str)
+#         instance.keep = Marshal.load(str)
+#         instance
+#       end
+#     end
+#
+#     a = Example.instance
+#     a.keep = "keep this"
+#     a.strip = "get rid of this"
+#
+#     stored_state = Marshal.dump(a)
+#
+#     a.keep = nil
+#     a.strip = nil
+#     b = Marshal.load(stored_state)
+#     p a == b  #  => true
+#     p a.keep  #  => "keep this"
+#     p a.strip #  => nil
+module Singleton
+  def self.__init__: (Class klass) -> Class
+
+  def self.instance: () -> instance
+
+  public
+
+  # By default, do not retain any state when marshalling.
+  #
+  def _dump: (?Integer depth) -> String
+
+  # Raises a TypeError to prevent cloning.
+  #
+  def clone: () -> bot
+
+  # Raises a TypeError to prevent duping.
+  #
+  def dup: () -> bot
+end
+
+Singleton::VERSION: String