steep 0.11.1 → 0.12.0

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

@@ -0,0 +1,135 @@
+# 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

@@ -0,0 +1,141 @@
+class MatchData < Object
+  def ==: (untyped arg0) -> bool
+
+  def []: (Integer i_or_start_or_range_or_name) -> String?
+        | (Integer i_or_start_or_range_or_name, ?Integer length) -> ::Array[String]
+        | (::Range[Integer] i_or_start_or_range_or_name) -> ::Array[String]
+        | (String | Symbol i_or_start_or_range_or_name) -> String?
+
+  def begin: (Integer | String | Symbol n) -> Integer?
+
+  # Returns the array of captures; equivalent to `mtch.to_a[1..-1]` .
+  # 
+  # ```ruby
+  # f1,f2,f3,f4 = /(.)(.)(\d+)(\d)/.match("THX1138.").captures
+  # f1    #=> "H"
+  # f2    #=> "X"
+  # f3    #=> "113"
+  # f4    #=> "8"
+  # ```
+  def captures: () -> ::Array[String]
+
+  def `end`: (Integer | String | Symbol n) -> Integer?
+
+  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
+
+  def inspect: () -> String
+
+  # Returns the number of elements in the match array.
+  # 
+  # ```ruby
+  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  # m.length   #=> 5
+  # m.size     #=> 5
+  # ```
+  def length: () -> Integer
+
+  # Returns a [Hash](https://ruby-doc.org/core-2.6.3/Hash.html) 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.
+  # 
+  # ```ruby
+  # m = /(?.)(?.)/.match("01")
+  # m.named_captures #=> {"a" => "0", "b" => "1"}
+  # 
+  # m = /(?.)(?.)?/.match("0")
+  # m.named_captures #=> {"a" => "0", "b" => nil}
+  # 
+  # m = /(?.)(?.)/.match("01")
+  # m.named_captures #=> {"a" => "1"}
+  # 
+  # m = /(?x)|(?y)/.match("x")
+  # m.named_captures #=> {"a" => "x"}
+  # ```
+  def named_captures: () -> ::Hash[String, String?]
+
+  def names: () -> ::Array[String]
+
+  def offset: (Integer | Symbol | String n) -> ([Integer, Integer] | [nil, nil])
+
+  # Returns the portion of the original string after the current match.
+  # Equivalent to the special variable `$'` .
+  # 
+  # ```ruby
+  # 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 `` $` `` .
+  # 
+  # ```ruby
+  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  # m.pre_match   #=> "T"
+  # ```
+  def pre_match: () -> String
+
+  # Returns the regexp.
+  # 
+  # ```ruby
+  # m = /a.*b/.match("abc")
+  # m.regexp #=> /a.*b/
+  # ```
+  def regexp: () -> Regexp
+
+  # Returns the number of elements in the match array.
+  # 
+  # ```ruby
+  # 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` .
+  # 
+  # ```ruby
+  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  # m.string   #=> "THX1138."
+  # ```
+  def string: () -> String
+
+  # Returns the array of matches.
+  # 
+  # ```ruby
+  # 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).
+  # 
+  # ```ruby
+  # 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.
+  # 
+  # ```ruby
+  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  # m.to_s   #=> "HX1138"
+  # ```
+  def to_s: () -> String
+
+  def values_at: (*Integer | Symbol | String indexes) -> ::Array[String?]
+end

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

@@ -0,0 +1,66 @@
+# 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

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

@@ -0,0 +1,182 @@
+class Method < Object
+  # Returns a `Proc` object corresponding to this method.
+  def to_proc: () -> Proc
+
+  # Invokes the *meth* with the specified arguments, returning the method’s
+  # return value.
+  # 
+  # ```ruby
+  # m = 12.method("+")
+  # m.call(3)    #=> 15
+  # m.call(20)   #=> 32
+  # ```
+  def call: (*untyped args) -> untyped
+
+  # Returns a proc that is the composition of this method and the given *g*
+  # . The returned proc takes a variable number of arguments, calls *g* with
+  # them then calls this method with the result.
+  # 
+  # ```ruby
+  # def f(x)
+  #   x * x
+  # end
+  # 
+  # f = self.method(:f)
+  # g = proc {|x| x + x }
+  # p (f << g).call(2) #=> 16
+  # ```
+  def <<: (untyped g) -> untyped
+
+  # Invokes the method with `obj` as the parameter like
+  # [call](Method.downloaded.ruby_doc#method-i-call). This allows a method
+  # object to be the target of a `when` clause in a case statement.
+  # 
+  # ```ruby
+  # require 'prime'
+  # 
+  # case 1373
+  # when Prime.method(:prime?)
+  #   # ...
+  # end
+  # ```
+  def ===: (*untyped obj) -> untyped
+
+  # Returns a proc that is the composition of this method and the given *g*
+  # . The returned proc takes a variable number of arguments, calls *g* with
+  # them then calls this method with the result.
+  # 
+  # ```ruby
+  # def f(x)
+  #   x * x
+  # end
+  # 
+  # f = self.method(:f)
+  # g = proc {|x| x + x }
+  # p (f >> g).call(2) #=> 8
+  # ```
+  def >>: (untyped g) -> untyped
+
+  # Invokes the *meth* with the specified arguments, returning the method’s
+  # return value.
+  # 
+  # ```ruby
+  # m = 12.method("+")
+  # m.call(3)    #=> 15
+  # m.call(20)   #=> 32
+  # ```
+  def []: (*untyped args) -> untyped
+
+  # Returns an indication of the number of arguments accepted by a method.
+  # Returns a nonnegative integer for methods that take a fixed number of
+  # arguments. For Ruby methods that take a variable number of arguments,
+  # returns -n-1, where n is the number of required arguments. Keyword
+  # arguments will be considered as a single additional argument, that
+  # argument being mandatory if any keyword argument is mandatory. For
+  # methods written in C, returns -1 if the call takes a variable number of
+  # arguments.
+  # 
+  #     class C
+  #       def one;    end
+  #       def two(a); end
+  #       def three(*a);  end
+  #       def four(a, b); end
+  #       def five(a, b, *c);    end
+  #       def six(a, b, *c, &d); end
+  #       def seven(a, b, x:0); end
+  #       def eight(x:, y:); end
+  #       def nine(x:, y:, **z); end
+  #       def ten(*a, x:, y:); end
+  #     end
+  #     c = C.new
+  #     c.method(:one).arity     #=> 0
+  #     c.method(:two).arity     #=> 1
+  #     c.method(:three).arity   #=> -1
+  #     c.method(:four).arity    #=> 2
+  #     c.method(:five).arity    #=> -3
+  #     c.method(:six).arity     #=> -3
+  #     c.method(:seven).arity   #=> -3
+  #     c.method(:eight).arity   #=> 1
+  #     c.method(:nine).arity    #=> 1
+  #     c.method(:ten).arity     #=> -2
+  # 
+  #     "cat".method(:size).arity      #=> 0
+  #     "cat".method(:replace).arity   #=> 1
+  #     "cat".method(:squeeze).arity   #=> -1
+  #     "cat".method(:count).arity     #=> -1
+  def arity: () -> Integer
+
+  # Returns a clone of this method.
+  # 
+  # ```ruby
+  # class A
+  #   def foo
+  #     return "bar"
+  #   end
+  # end
+  # 
+  # m = A.new.method(:foo)
+  # m.call # => "bar"
+  # n = m.clone.call # => "bar"
+  # ```
+  def clone: () -> Method
+
+  def curry: (*untyped args) -> untyped
+
+  # Returns the name of the method.
+  def name: () -> Symbol
+
+  # Returns the original name of the method.
+  # 
+  # ```ruby
+  # class C
+  #   def foo; end
+  #   alias bar foo
+  # end
+  # C.instance_method(:bar).original_name # => :foo
+  # ```
+  def original_name: () -> Symbol
+
+  # Returns the class or module that defines the method. See also receiver.
+  # 
+  # ```ruby
+  # (1..3).method(:map).owner #=> Enumerable
+  # ```
+  def owner: () -> (Class | Module)
+
+  # Returns the parameter information of this method.
+  # 
+  # ```ruby
+  # def foo(bar); end
+  # method(:foo).parameters #=> [[:req, :bar]]
+  # 
+  # def foo(bar, baz, bat, &blk); end
+  # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:req, :bat], [:block, :blk]]
+  # 
+  # def foo(bar, *args); end
+  # method(:foo).parameters #=> [[:req, :bar], [:rest, :args]]
+  # 
+  # def foo(bar, baz, *args, &blk); end
+  # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:rest, :args], [:block, :blk]]
+  # ```
+  def parameters: () -> ::Array[untyped]
+
+  # Returns the bound receiver of the method object.
+  # 
+  # ```ruby
+  # (1..3).method(:map).receiver # => 1..3
+  # ```
+  def receiver: () -> untyped
+
+  # Returns the Ruby source filename and line number containing this method
+  # or nil if this method was not defined in Ruby (i.e. native).
+  def source_location: () -> untyped
+
+  # Returns a [Method](Method.downloaded.ruby_doc) of superclass which would
+  # be called when super is used or nil if there is no method on superclass.
+  def super_method: () -> Method?
+
+  # Dissociates *meth* from its current receiver. The resulting
+  # `UnboundMethod` can subsequently be bound to a new object of the same
+  # class (see `UnboundMethod` ).
+  def unbind: () -> untyped
+end