steep 0.13.0 → 0.16.2

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,141 +0,0 @@
-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

@@ -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

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

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