rbs 0.13.1 → 0.18.0

data/sig/rbs.rbs

@@ -1,3 +1,11 @@
 module RBS
   def self.logger: () -> Logger
+                 
+  def self.logger_level: () -> untyped
+                  
+  def self.logger_level=: (untyped) -> untyped
+                   
+  def self.logger_output: () -> IO
+                   
+  def self.logger_output=: (IO) -> IO
 end

data/sig/repository.rbs

@@ -0,0 +1,79 @@
+module RBS
+  # Set of RBS repositories.
+  #
+  # A repository object can handle multiple repository roots.
+  #
+  #   repo = RBS::Repository.new()
+  #   repo.add(Pathname("vendor/rbs/gem-rbs"))
+  #   repo.add(Pathname("vendor/rbs/internal-rbs"))
+  #   repo.add(Pathname("vendor/rbs/definitely-rbs"))
+  #
+  #   repo.lookup("minitest", "2.1.3") => Pathname or nil
+  #
+  # If one gem version can resolve to several directories, the last added dir wins.
+  #
+  class Repository
+    class GemRBS
+      attr_reader name: String
+
+      # Array of gem dirs.
+      # Gem dir contains directories for each version.
+      attr_reader paths: Array[Pathname]
+
+      # Hash from a version to VersionPath object.
+      attr_reader versions(): Hash[Gem::Version, VersionPath]
+
+      @versions: Hash[Gem::Version, VersionPath]?
+
+      def initialize: (name: String) -> void
+
+      def load!: () -> void
+
+      def version_names: () -> Array[Gem::Version]
+
+      def oldest_version: () -> VersionPath
+
+      def latest_version: () -> VersionPath
+
+      def find_best_version: (Gem::Version?) -> VersionPath
+
+      # Returns true if versions is empty.
+      def empty?: () -> bool
+    end
+
+    class VersionPath
+      attr_reader gem: GemRBS
+      attr_reader version: Gem::Version
+      attr_reader path: Pathname
+
+      def initialize: (gem: GemRBS, version: Gem::Version, path: Pathname) -> void
+    end
+
+    DEFAULT_STDLIB_ROOT: Pathname
+
+    # Array of _root dir_s of repositories.
+    #
+    attr_reader dirs: Array[Pathname]
+
+    attr_reader gems: Hash[String, GemRBS]
+
+    # An optional keyword argument `no_stdlib` is to skip adding directory for stdlib classes.
+    # Passing truthy value will skip loading stdlib. (You can add the stdlib root by yourself.)
+    #
+    def initialize: (?no_stdlib: bool) -> void
+
+    # Add new _root dir_ to the repository set.
+    # If two repository dirs have exactly same gem-version definitions, the latter overwrites the prior.
+    #
+    def add: (Pathname dir) -> void
+
+    # Returns a directory for given `gem` name and `version`.
+    # `version` can be `nil` for _any version_.
+    #
+    # If the given gem cannot be found, it returns `nil`.
+    #
+    def lookup: (String gem, String? version) -> Pathname?
+
+    def lookup_path: (String gem, String? version) -> [GemRBS, VersionPath]?
+  end
+end

data/sig/substitution.rbs

@@ -1,6 +1,6 @@
 module RBS
   # Substitution from type variables to types.
-  # 
+  #
   # The substitution construction is in _destructive_ manner.
   #
   #    sub = Substitution.new
@@ -25,7 +25,7 @@ module RBS
     # Utility method to construct a substitution.
     # Raises an error when `variables.size != types.size`.
     # `instance_type` defaults to `nil`.
-    # 
+    #
     # Yields types in `types` and the block value is used if block is given.
     #
     def self.build: (Array[Symbol] variables, Array[Types::t] types, ?instance_type: Types::t?) ?{ (Types::t) -> Types::t } -> instance
@@ -36,4 +36,4 @@ module RBS
     # Returns a substitution without variables given in `vars`.
     def without: (*Symbol vars) -> Substitution
   end
-end
+end

data/sig/typename.rbs

@@ -1,6 +1,6 @@
 module RBS
   # TypeName represents name of types in RBS.
-  # 
+  #
   # TypeNames are one of the three kind, class, alias, and interface.
   # *class* type names corresponds to Ruby classes and modules.
   # There are no corresponding Ruby value to *alias* and *interface* type names.

data/sig/types.rbs

@@ -154,7 +154,7 @@ module RBS
 
       include NoFreeVariables
       include NoSubst
-      include EmptyEachType      
+      include EmptyEachType
     end
 
     module Application

data/sig/vendorer.rbs

@@ -0,0 +1,44 @@
+module RBS
+  # Copies RBS files loaded through `loader` under `vendor_dir`.
+  # 
+  # Core libraries and library RBS files will be copied.
+  # 
+  #   loader = RBS::EnvironmentLoader.new()
+  # 
+  #   loader.add(library: set)               # Libraries will be copied.
+  #   loader.add(library: "minitest", version: "1.2.3")
+  # 
+  #   loader.add(path: Pathname("sig"))      # Dirs will be ignored.
+  # 
+  #   vendorer = RBS::Vendorer.new(vendor_dir: Pathname("vendor/rbs"), loader: loader)
+  #   vendorer.clearn!
+  #   vendorer.copy!
+  # 
+  # The result will be:
+  #   vendor/rbs/core            => Will include core RBSs
+  #   vendor/rbs/set-0           => Will include `set` library RBSs.
+  #   vendor/rbs/minitest-1.2.3  => Will include `minitest` library RBSs.
+  # 
+  # The vendorerd RBSs will be loaded through :dir source.
+  # 
+  #   loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: true))
+  #   loader.add(path: Pathname("vendor/rbs"))
+  #   loader.add(path: Pathname("sig"))
+  # 
+  class Vendorer
+    attr_reader vendor_dir: Pathname
+    attr_reader loader: EnvironmentLoader
+
+    def initialize: (vendor_dir: Pathname, loader: EnvironmentLoader) -> void
+    
+    # Copy RBS files into `vendor_dir`.
+    # Ensures the `vendor_dir` exists.
+    def copy!: () -> void
+
+    # Deletes `vendor_dir` and its content if exists.
+    # 
+    def clean!: () -> void
+    
+    def ensure_dir: [A] () { () -> A } -> A
+  end
+end

data/sig/writer.rbs

@@ -4,37 +4,37 @@ module RBS
     attr_reader indentation: Array[String]
 
     def initialize: (out: IO) -> void
-                  
+
     def indent: (?Integer size) { () -> void } -> void
-              
+
     def prefix: () -> String
-              
+
     def puts: (?String) -> void
-            
+
     def write_annotation: (Array[AST::Annotation]) -> void
-                        
+
     def write_comment: (AST::Comment?) -> void
-                     
+
     def write: (Array[AST::Declarations::t]) -> void
-             
+
     def write_decl: (AST::Declarations::t) -> void
-                  
+
     def write_member: (AST::Declarations::Module::member) -> void
-                  
+
     def name_and_params: (TypeName, AST::Declarations::ModuleTypeParams) -> String?
-                       
+
     def name_and_args: (TypeName, Array[Types::t]) -> String?
-                     
+
     def method_name: (Symbol) -> String
-                   
+
     def write_def: (AST::Members::MethodDefinition) -> void
-                 
+
     def attribute: (:reader | :writer | :accessor, AST::Members::Attribute) -> void
-                 
+
     interface _Located
       def location: () -> Location?
     end
-                 
+
     def preserve_empty_line: (_Located?, _Located) -> void
   end
 end

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/benchmark/{benchmark.rbs → 0/benchmark.rbs}

@@ -53,9 +53,9 @@
 #     times:    1.000000   0.000000   1.000000 (  1.003611)
 #     upto:     1.030000   0.000000   1.030000 (  1.028098)
 #
-# *   The times for some benchmarks depend on the order in which items are run. 
+# *   The times for some benchmarks depend on the order in which items are run.
 #     These differences are due to the cost of memory allocation and garbage
-#     collection. To avoid these discrepancies, the #bmbm method is provided. 
+#     collection. To avoid these discrepancies, the #bmbm method is provided.
 #     For example, to compare ways to sort an array of floats:
 #
 #         require 'benchmark'

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.
   #
@@ -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 → 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