steep 0.14.0 → 0.16.3

data/vendor/ruby-signature/stdlib/builtin/marshal.rbs

@@ -1,135 +0,0 @@
-# The marshaling library converts collections of Ruby objects into a byte
-# stream, allowing them to be stored outside the currently active script.
-# This data may subsequently be read and the original objects
-# reconstituted.
-# 
-# Marshaled data has major and minor version numbers stored along with the
-# object information. In normal use, marshaling can only load data written
-# with the same major version number and an equal or lower minor version
-# number. If Ruby’s “verbose” flag is set (normally using -d, -v, -w, or
-# –verbose) the major and minor numbers must match exactly.
-# [Marshal](Marshal) versioning is independent of
-# Ruby’s version numbers. You can extract the version by reading the
-# first two bytes of marshaled data.
-# 
-# ```ruby
-# str = Marshal.dump("thing")
-# RUBY_VERSION   #=> "1.9.0"
-# str[0].ord     #=> 4
-# str[1].ord     #=> 8
-# ```
-# 
-# Some objects cannot be dumped: if the objects to be dumped include
-# bindings, procedure or method objects, instances of class
-# [IO](https://ruby-doc.org/core-2.6.3/IO.html), or singleton objects, a
-# [TypeError](https://ruby-doc.org/core-2.6.3/TypeError.html) will be
-# raised.
-# 
-# If your class has special serialization needs (for example, if you want
-# to serialize in some specific format), or if it contains objects that
-# would otherwise not be serializable, you can implement your own
-# serialization strategy.
-# 
-# There are two methods of doing this, your object can define either
-# marshal\_dump and marshal\_load or \_dump and \_load. marshal\_dump will
-# take precedence over \_dump if both are defined. marshal\_dump may
-# result in smaller [Marshal](Marshal) strings.
-# 
-# 
-# By design, [::load](Marshal#method-c-load) can
-# deserialize almost any class loaded into the Ruby process. In many cases
-# this can lead to remote code execution if the
-# [Marshal](Marshal) data is loaded from an untrusted
-# source.
-# 
-# As a result, [::load](Marshal#method-c-load) is not
-# suitable as a general purpose serialization format and you should never
-# unmarshal user supplied input or other untrusted data.
-# 
-# If you need to deserialize untrusted data, use JSON or another
-# serialization format that is only able to load simple, ‘primitive’ types
-# such as [String](https://ruby-doc.org/core-2.6.3/String.html),
-# [Array](https://ruby-doc.org/core-2.6.3/Array.html),
-# [Hash](https://ruby-doc.org/core-2.6.3/Hash.html), etc. Never allow
-# user input to specify arbitrary types to deserialize into.
-# 
-# 
-# When dumping an object the method marshal\_dump will be called.
-# marshal\_dump must return a result containing the information necessary
-# for marshal\_load to reconstitute the object. The result can be any
-# object.
-# 
-# When loading an object dumped using marshal\_dump the object is first
-# allocated then marshal\_load is called with the result from
-# marshal\_dump. marshal\_load must recreate the object from the
-# information in the result.
-# 
-# Example:
-# 
-# ```ruby
-# class MyObj
-#   def initialize name, version, data
-#     @name    = name
-#     @version = version
-#     @data    = data
-#   end
-# 
-#   def marshal_dump
-#     [@name, @version]
-#   end
-# 
-#   def marshal_load array
-#     @name, @version = array
-#   end
-# end
-# ```
-# 
-# 
-# Use \_dump and \_load when you need to allocate the object you’re
-# restoring yourself.
-# 
-# When dumping an object the instance method \_dump is called with an
-# [Integer](https://ruby-doc.org/core-2.6.3/Integer.html) which indicates
-# the maximum depth of objects to dump (a value of -1 implies that you
-# should disable depth checking). \_dump must return a
-# [String](https://ruby-doc.org/core-2.6.3/String.html) containing the
-# information necessary to reconstitute the object.
-# 
-# The class method \_load should take a
-# [String](https://ruby-doc.org/core-2.6.3/String.html) and use it to
-# return an object of the same class.
-# 
-# Example:
-# 
-# ```ruby
-# class MyObj
-#   def initialize name, version, data
-#     @name    = name
-#     @version = version
-#     @data    = data
-#   end
-# 
-#   def _dump level
-#     [@name, @version].join ':'
-#   end
-# 
-#   def self._load args
-#     new(*args.split(':'))
-#   end
-# end
-# ```
-# 
-# Since [::dump](Marshal#method-c-dump) outputs a
-# string you can have \_dump return a
-# [Marshal](Marshal) string which is Marshal.loaded in
-# \_load for complex objects.
-module Marshal
-  def self.dump: (Object arg0, ?IO arg1, ?Integer arg2) -> Object
-               | (Object arg0, ?Integer arg1) -> Object
-
-  def self.load: (String arg0, ?Proc arg1) -> Object
-end
-
-Marshal::MAJOR_VERSION: Integer
-
-Marshal::MINOR_VERSION: Integer

data/vendor/ruby-signature/stdlib/builtin/match_data.rbs

@@ -1,271 +0,0 @@
-# MatchData encapsulates the result of matching a Regexp against string. It is
-# returned by Regexp#match and String#match, and also stored in a global
-# variable returned by Regexp.last_match.
-#
-# Usage:
-#
-#     url = 'https://docs.ruby-lang.org/en/2.5.0/MatchData.html'
-#     m = url.match(/(\d\.?)+/)   # => #<MatchData "2.5.0" 1:"0">
-#     m.string                    # => "https://docs.ruby-lang.org/en/2.5.0/MatchData.html"
-#     m.regexp                    # => /(\d\.?)+/
-#     # entire matched substring:
-#     m[0]                        # => "2.5.0"
-#
-#     # Working with unnamed captures
-#     m = url.match(%r{([^/]+)/([^/]+)\.html$})
-#     m.captures                  # => ["2.5.0", "MatchData"]
-#     m[1]                        # => "2.5.0"
-#     m.values_at(1, 2)           # => ["2.5.0", "MatchData"]
-#
-#     # Working with named captures
-#     m = url.match(%r{(?<version>[^/]+)/(?<module>[^/]+)\.html$})
-#     m.captures                  # => ["2.5.0", "MatchData"]
-#     m.named_captures            # => {"version"=>"2.5.0", "module"=>"MatchData"}
-#     m[:version]                 # => "2.5.0"
-#     m.values_at(:version, :module)
-#                                 # => ["2.5.0", "MatchData"]
-#     # Numerical indexes are working, too
-#     m[1]                        # => "2.5.0"
-#     m.values_at(1, 2)           # => ["2.5.0", "MatchData"]
-#
-# ## Global variables equivalence
-#
-# Parts of last MatchData (returned by Regexp.last_match) are also aliased as
-# global variables:
-#
-# *   `$~` is Regexp.last_match;
-# *   `$&` is [Regexp.last_match](0);
-# *   `$1`, `$2`, and so on are [Regexp.last_match](i) (captures by number);
-# *   `$`` is Regexp.last_match`.pre_match`;
-# *   `$'` is Regexp.last_match`.post_match`;
-# *   `$+` is [Regexp.last_match](-1) (the last capture).
-#
-#
-# See also "Special global variables" section in Regexp documentation.
-#
-class MatchData
-  public
-
-  # Equality---Two matchdata are equal if their target strings, patterns, and
-  # matched positions are identical.
-  #
-  def ==: (untyped other) -> bool
-
-  # Match Reference -- MatchData acts as an array, and may be accessed using the
-  # normal array indexing techniques.  `mtch[0]` is equivalent to the special
-  # variable `$&`, and returns the entire matched string.  `mtch[1]`, `mtch[2]`,
-  # and so on return the values of the matched backreferences (portions of the
-  # pattern between parentheses).
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m          #=> #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
-  #     m[0]       #=> "HX1138"
-  #     m[1, 2]    #=> ["H", "X"]
-  #     m[1..3]    #=> ["H", "X", "113"]
-  #     m[-3, 2]   #=> ["X", "113"]
-  #
-  #     m = /(?<foo>a+)b/.match("ccaaab")
-  #     m          #=> #<MatchData "aaab" foo:"aaa">
-  #     m["foo"]   #=> "aaa"
-  #     m[:foo]    #=> "aaa"
-  #
-  def []: (Integer idx) -> String?
-        | (Integer start, Integer length) -> ::Array[String?]
-        | (::Range[Integer] range) -> ::Array[String?]
-        | (String | Symbol name) -> String?
-
-  # Returns the offset of the start of the *n*th element of the match array in the
-  # string. *n* can be a string or symbol to reference a named capture.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.begin(0)       #=> 1
-  #     m.begin(2)       #=> 2
-  #
-  #     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
-  #     p m.begin(:foo)  #=> 0
-  #     p m.begin(:bar)  #=> 2
-  #
-  def begin: (Integer | String | Symbol n_or_name) -> Integer?
-
-  # Returns the array of captures; equivalent to `mtch.to_a[1..-1]`.
-  #
-  #     f1,f2,f3,f4 = /(.)(.)(\d+)(\d)/.match("THX1138.").captures
-  #     f1    #=> "H"
-  #     f2    #=> "X"
-  #     f3    #=> "113"
-  #     f4    #=> "8"
-  #
-  def captures: () -> ::Array[String?] 
-
-  # Returns the offset of the character immediately following the end of the *n*th
-  # element of the match array in the string. *n* can be a string or symbol to
-  # reference a named capture.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.end(0)         #=> 7
-  #     m.end(2)         #=> 3
-  #
-  #     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
-  #     p m.end(:foo)    #=> 1
-  #     p m.end(:bar)    #=> 3
-  #
-  def `end`: (Integer | String | Symbol n_or_name) -> Integer?
-
-  # Equality---Two matchdata are equal if their target strings, patterns, and
-  # matched positions are identical.
-  #
-  def eql?: (untyped other) -> bool
-
-  # Produce a hash based on the target string, regexp and matched positions of
-  # this matchdata.
-  #
-  # See also Object#hash.
-  #
-  def hash: () -> Integer
-
-  # Returns a printable version of *mtch*.
-  #
-  #     puts /.$/.match("foo").inspect
-  #     #=> #<MatchData "o">
-  #
-  #     puts /(.)(.)(.)/.match("foo").inspect
-  #     #=> #<MatchData "foo" 1:"f" 2:"o" 3:"o">
-  #
-  #     puts /(.)(.)?(.)/.match("fo").inspect
-  #     #=> #<MatchData "fo" 1:"f" 2:nil 3:"o">
-  #
-  #     puts /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").inspect
-  #     #=> #<MatchData "hog" foo:"h" bar:"o" baz:"g">
-  #
-  def inspect: () -> String
-
-  # Returns the number of elements in the match array.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.length   #=> 5
-  #     m.size     #=> 5
-  #
-  def length: () -> Integer
-
-  # Returns a Hash using named capture.
-  #
-  # A key of the hash is a name of the named captures. A value of the hash is a
-  # string of last successful capture of corresponding group.
-  #
-  #     m = /(?<a>.)(?<b>.)/.match("01")
-  #     m.named_captures #=> {"a" => "0", "b" => "1"}
-  #
-  #     m = /(?<a>.)(?<b>.)?/.match("0")
-  #     m.named_captures #=> {"a" => "0", "b" => nil}
-  #
-  #     m = /(?<a>.)(?<a>.)/.match("01")
-  #     m.named_captures #=> {"a" => "1"}
-  #
-  #     m = /(?<a>x)|(?<a>y)/.match("x")
-  #     m.named_captures #=> {"a" => "x"}
-  #
-  def named_captures: () -> ::Hash[String, String?]
-
-  # Returns a list of names of captures as an array of strings. It is same as
-  # mtch.regexp.names.
-  #
-  #     /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").names
-  #     #=> ["foo", "bar", "baz"]
-  #
-  #     m = /(?<x>.)(?<y>.)?/.match("a") #=> #<MatchData "a" x:"a" y:nil>
-  #     m.names                          #=> ["x", "y"]
-  #
-  def names: () -> ::Array[String]
-
-  # Returns a two-element array containing the beginning and ending offsets of the
-  # *n*th match. *n* can be a string or symbol to reference a named capture.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.offset(0)      #=> [1, 7]
-  #     m.offset(4)      #=> [6, 7]
-  #
-  #     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
-  #     p m.offset(:foo) #=> [0, 1]
-  #     p m.offset(:bar) #=> [2, 3]
-  #
-  def offset: (Integer | Symbol | String n_or_name) -> ([ Integer, Integer ] | [ nil, nil ])
-
-  # Returns the portion of the original string after the current match. Equivalent
-  # to the special variable `$'`.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie")
-  #     m.post_match   #=> ": The Movie"
-  #
-  def post_match: () -> String
-
-  # Returns the portion of the original string before the current match.
-  # Equivalent to the special variable `$``.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.pre_match   #=> "T"
-  #
-  def pre_match: () -> String
-
-  # Returns the regexp.
-  #
-  #     m = /a.*b/.match("abc")
-  #     m.regexp #=> /a.*b/
-  #
-  def regexp: () -> Regexp
-
-  # Returns the number of elements in the match array.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.length   #=> 5
-  #     m.size     #=> 5
-  #
-  def size: () -> Integer
-
-  # Returns a frozen copy of the string passed in to `match`.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.string   #=> "THX1138."
-  #
-  def string: () -> String
-
-  # Returns the array of matches.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.to_a   #=> ["HX1138", "H", "X", "113", "8"]
-  #
-  # Because `to_a` is called when expanding `*`*variable*, there's a useful
-  # assignment shortcut for extracting matched fields. This is slightly slower
-  # than accessing the fields directly (as an intermediate array is generated).
-  #
-  #     all,f1,f2,f3 = * /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     all   #=> "HX1138"
-  #     f1    #=> "H"
-  #     f2    #=> "X"
-  #     f3    #=> "113"
-  #
-  def to_a: () -> ::Array[String?]
-
-  # Returns the entire matched string.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  #     m.to_s   #=> "HX1138"
-  #
-  def to_s: () -> String
-
-  # Uses each *index* to access the matching values, returning an array of the
-  # corresponding matches.
-  #
-  #     m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie")
-  #     m.to_a               #=> ["HX1138", "H", "X", "113", "8"]
-  #     m.values_at(0, 2, -2)   #=> ["HX1138", "X", "113"]
-  #
-  #     m = /(?<a>\d+) *(?<op>[+\-*\/]) *(?<b>\d+)/.match("1 + 2")
-  #     m.to_a               #=> ["1 + 2", "1", "+", "2"]
-  #     m.values_at(:a, :b, :op) #=> ["1", "2", "+"]
-  #
-  def values_at: (*Integer | Symbol | String n_or_name) -> ::Array[String?]
-
-  private
-
-  def initialize_copy: (self object) -> void
-end

data/vendor/ruby-signature/stdlib/builtin/math.rbs

@@ -1,66 +0,0 @@
-# The [Math](Math) module contains module functions
-# for basic trigonometric and transcendental functions. See class
-# [Float](https://ruby-doc.org/core-2.6.3/Float.html) for a list of
-# constants that define Ruby's floating point accuracy.
-# 
-# Domains and codomains are given only for real (not complex) numbers.
-module Math
-  def self.acos: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.acosh: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.asin: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.asinh: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.atan: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.atan2: (Integer | Float | Rational | BigDecimal y, Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.atanh: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.cbrt: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.cos: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.cosh: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.erf: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.erfc: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.exp: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.frexp: (Integer | Float | Rational | BigDecimal x) -> [ Integer | Float | Rational | BigDecimal, Integer | Float | Rational | BigDecimal ]
-
-  def self.gamma: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.hypot: (Integer | Float | Rational | BigDecimal x, Integer | Float | Rational | BigDecimal y) -> Float
-
-  def self.ldexp: (Integer | Float | Rational | BigDecimal fraction, Integer | Float | Rational | BigDecimal exponent) -> Float
-
-  def self.lgamma: (Integer | Float | Rational | BigDecimal x) -> (Integer | Float)
-
-  def self.log: (Integer | Float | Rational | BigDecimal x, ?Integer | Float | Rational | BigDecimal base) -> Float
-
-  def self.log10: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.log2: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.sin: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.sinh: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.sqrt: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.tan: (Integer | Float | Rational | BigDecimal x) -> Float
-
-  def self.tanh: (Integer | Float | Rational | BigDecimal x) -> Float
-end
-
-Math::E: Float
-
-Math::PI: Float
-
-class Math::DomainError < StandardError
-end