steep 0.13.0 → 0.16.2

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

@@ -1,91 +0,0 @@
-class TracePoint < Object
-  def initialize: (*Symbol events) { (TracePoint tp) -> void } -> void
-
-  # Returns internal information of
-  # [TracePoint](TracePoint.downloaded.ruby_doc).
-  # 
-  # The contents of the returned value are implementation specific. It may
-  # be changed in future.
-  # 
-  # This method is only for debugging
-  # [TracePoint](TracePoint.downloaded.ruby_doc) itself.
-  def self.stat: () -> untyped
-
-  def self.trace: (*Symbol events) { (TracePoint tp) -> void } -> TracePoint
-
-  # Return the generated binding object from event
-  def binding: () -> Binding
-
-  # Return the called name of the method being called
-  def callee_id: () -> Symbol
-
-  def `defined_class`: () -> Module
-
-  # Deactivates the trace
-  # 
-  # Return true if trace was enabled. Return false if trace was disabled.
-  # 
-  # ```ruby
-  # trace.enabled?       #=> true
-  # trace.disable        #=> true (previous status)
-  # trace.enabled?       #=> false
-  # trace.disable        #=> false
-  # ```
-  # 
-  # If a block is given, the trace will only be disable within the scope of
-  # the block.
-  # 
-  # ```ruby
-  # trace.enabled?
-  # #=> true
-  # 
-  # trace.disable do
-  #     trace.enabled?
-  #     # only disabled for this block
-  # end
-  # 
-  # trace.enabled?
-  # #=> true
-  # ```
-  # 
-  # Note: You cannot access event hooks within the block.
-  # 
-  # ```ruby
-  # trace.disable { p tp.lineno }
-  # #=> RuntimeError: access from outside
-  # ```
-  def disable: () -> bool
-             | () { () -> void } -> void
-
-  def enable: () -> bool
-            | () { () -> void } -> void
-
-  # The current status of the trace
-  def enabled?: () -> bool
-
-  def inspect: () -> String
-
-  # Line number of the event
-  def lineno: () -> Integer
-
-  # Return the name at the definition of the method being called
-  def method_id: () -> Symbol
-
-  # Path of the file being run
-  def path: () -> String
-
-  # Value from exception raised on the `:raise` event
-  def raised_exception: () -> untyped
-
-  # Return value from `:return`, `c_return`, and `b_return` event
-  def return_value: () -> untyped
-
-  # Return the trace object during event
-  # 
-  # Same as [\#binding](TracePoint.downloaded.ruby_doc#method-i-binding):
-  # 
-  # ```ruby
-  # trace.binding.eval('self')
-  # ```
-  def `self`: () -> Binding
-end

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

@@ -1,46 +0,0 @@
-# The global value `true` is the only instance of class TrueClass and represents
-# a logically true value in boolean expressions. The class provides operators
-# allowing `true` to be used in logical expressions.
-# 
-class TrueClass
-  public
-
-  def !: () -> bool
-
-  # And---Returns `false` if *obj* is `nil` or `false`, `true` otherwise.
-  # 
-  def &: (nil) -> false
-       | (false) -> false
-       | (untyped obj) -> bool
-
-  # Case Equality -- For class Object, effectively the same as calling `#==`, but
-  # typically overridden by descendants to provide meaningful semantics in `case`
-  # statements.
-  # 
-  def ===: (true) -> true
-         | (untyped obj) -> bool
-
-  # Exclusive Or---Returns `true` if *obj* is `nil` or `false`, `false` otherwise.
-  # 
-  def ^: (nil) -> true
-       | (false) -> true
-       | (untyped obj) -> bool
-
-  alias inspect to_s
-
-  # The string representation of `true` is "true".
-  # 
-  def to_s: () -> "true"
-
-  # Or---Returns `true`. As *obj* is an argument to a method call, it is always
-  # evaluated; there is no short-circuit evaluation in this case.
-  # 
-  #     true |  puts("or")
-  #     true || puts("logical or")
-  # 
-  # *produces:*
-  # 
-  #     or
-  # 
-  def |: (bool obj) -> bool
-end

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

@@ -1,159 +0,0 @@
-# Ruby supports two forms of objectified methods.
-# [Class](https://ruby-doc.org/core-2.6.3/Class.html) `Method` is used to
-# represent methods that are associated with a particular object: these
-# method objects are bound to that object. Bound method objects for an
-# object can be created using `Object#method` .
-# 
-# Ruby also supports unbound methods; methods objects that are not
-# associated with a particular object. These can be created either by
-# calling `Module#instance_method` or by calling `unbind` on a bound
-# method object. The result of both of these is an `UnboundMethod` object.
-# 
-# Unbound methods can only be called after they are bound to an object.
-# That object must be a kind\_of? the method's original class.
-# 
-# ```ruby
-# class Square
-#   def area
-#     @side * @side
-#   end
-#   def initialize(side)
-#     @side = side
-#   end
-# end
-# 
-# area_un = Square.instance_method(:area)
-# 
-# s = Square.new(12)
-# area = area_un.bind(s)
-# area.call   #=> 144
-# ```
-# 
-# Unbound methods are a reference to the method at the time it was
-# objectified: subsequent changes to the underlying class will not affect
-# the unbound method.
-# 
-# ```ruby
-# class Test
-#   def test
-#     :original
-#   end
-# end
-# um = Test.instance_method(:test)
-# class Test
-#   def test
-#     :modified
-#   end
-# end
-# t = Test.new
-# t.test            #=> :modified
-# um.bind(t).call   #=> :original
-# ```
-class UnboundMethod
-  # 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
-
-  # Bind *umeth* to *obj* . If `Klass` was the class from which *umeth* was
-  # obtained, `obj.kind_of?(Klass)` must be true.
-  # 
-  # ```ruby
-  # class A
-  #   def test
-  #     puts "In test, class = #{self.class}"
-  #   end
-  # end
-  # class B < A
-  # end
-  # class C < B
-  # end
-  # 
-  # um = B.instance_method(:test)
-  # bm = um.bind(C.new)
-  # bm.call
-  # bm = um.bind(B.new)
-  # bm.call
-  # bm = um.bind(A.new)
-  # bm.call
-  # ```
-  # 
-  # *produces:*
-  # 
-  #     In test, class = C
-  #     In test, class = B
-  #     prog.rb:16:in `bind': bind argument must be an instance of B (TypeError)
-  #      from prog.rb:16
-  def bind: (untyped obj) -> Method
-
-  # Returns the name of the method.
-  def name: () -> Symbol
-
-  # Returns the class or module that defines the method. See also receiver.
-  # 
-  # ```ruby
-  # (1..3).method(:map).owner #=> Enumerable
-  # ```
-  def owner: () -> 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[[ Symbol, Symbol ]]
-                | () -> ::Array[[ Symbol ]]
-
-  # 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: () -> [ String, Integer ]?
-
-  # Returns a [Method](https://ruby-doc.org/core-2.6.3/Method.html) of
-  # superclass which would be called when super is used or nil if there is
-  # no method on superclass.
-  def super_method: () -> UnboundMethod?
-end

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

@@ -1,17 +0,0 @@
-# The [Warning](Warning) module contains a single
-# method named [warn](Warning#method-i-warn), and the
-# module extends itself, making `Warning.warn` available.
-# [\#warn](Warning#method-i-warn) is called for all
-# warnings issued by Ruby. By default, warnings are printed to $stderr.
-# 
-# By overriding [\#warn](Warning#method-i-warn), you
-# can change how warnings are handled by Ruby, either filtering some
-# warnings, and/or outputting warnings somewhere other than $stderr. When
-# [\#warn](Warning#method-i-warn) is overridden, super
-# can be called to get the default behavior of printing the warning to
-# $stderr.
-module Warning
-  # Writes warning message msg to $stderr, followed by a newline if the message does not end in a newline.
-  # This method is called by Ruby for all emitted warnings.
-  def warn: (String) -> nil
-end

data/vendor/ruby-signature/stdlib/erb/erb.rbs

@@ -1,18 +0,0 @@
-class ERB
-  def self.version: () -> String
-
-  def initialize: (String, ?trim_mode: Integer | String | NilClass, ?eoutvar: String) -> untyped
-  def src: () -> String
-  def encoding: () -> Encoding
-  def filename: () -> (String | NilClass)
-  def filename=: (String | NilClass) -> untyped
-  def lineno: () -> Integer
-  def lineno=: (Integer) -> untyped
-  def location=: (Array[String | Integer]) -> untyped
-  def run: (?Binding) -> untyped
-  def result: (?Binding) -> String
-  def result_with_hash: (Hash[untyped, untyped]) -> String
-  def def_method: (Module, String, ?String) -> untyped
-  def def_module: (?String) -> Module
-  def def_class: (?Class, ?String) -> Class
-end

data/vendor/ruby-signature/stdlib/find/find.rbs

@@ -1,44 +0,0 @@
-# The `Find` module supports the top-down traversal of a set of file paths.
-# 
-# For example, to total the size of all files under your home directory,
-# ignoring anything in a "dot" directory (e.g. $HOME/.ssh):
-# 
-#     require 'find'
-# 
-#     total_size = 0
-# 
-#     Find.find(ENV["HOME"]) do |path|
-#       if FileTest.directory?(path)
-#         if File.basename(path).start_with?('.')
-#           Find.prune       # Don't look any further into this directory.
-#         else
-#           next
-#         end
-#       else
-#         total_size += FileTest.size(path)
-#       end
-#     end
-# 
-module Find
-  # Calls the associated block with the name of every file and directory listed as
-  # arguments, then recursively on their subdirectories, and so on.
-  # 
-  # Returns an enumerator if no block is given.
-  # 
-  # See the `Find` module documentation for an example.
-  # 
-  def self?.find: (*String | _ToPath paths, ?ignore_error: bool) -> Enumerator[String, nil]
-                | (*String | _ToPath paths, ?ignore_error: bool) { (String arg0) -> void } -> nil
-
-  # Skips the current file or directory, restarting the loop with the next entry.
-  # If the current file is a directory, that directory will not be recursively
-  # entered. Meaningful only within the block associated with Find::find.
-  # 
-  # See the `Find` module documentation for an example.
-  # 
-  def self?.prune: () -> void
-end
-
-interface _ToPath
-  def to_path: () -> String
-end

data/vendor/ruby-signature/stdlib/pathname/pathname.rbs

@@ -1,21 +0,0 @@
-class Pathname
-  def self.glob: (Pathname, ?Integer) -> Array[Pathname]
-  def `+`: (Pathname) -> Pathname
-         | (String) -> Pathname
-  def file?: -> bool
-  def relative_path_from: (Pathname) -> Pathname
-  def open: [X] (?String) { (IO) -> X } -> X
-  def join: (String) -> self
-  def realpath: -> self
-  def directory?: -> bool
-  def relative?: -> bool
-  def cleanpath: -> self
-  def read: -> String
-  def mkpath: -> void
-  def write: (String) -> void
-  def sub_ext: (String) -> self
-end
-
-extension Kernel (Pathname)
-  def Pathname: (String) -> Pathname
-end

data/vendor/ruby-signature/stdlib/prime/integer-extension.rbs

@@ -1,23 +0,0 @@
-extension Integer (Prime)
-  # Iterates the given block over all prime numbers.
-  #
-  # See Prime#each for more details.
-  #
-  def self.each_prime: (Integer) { (Integer) -> void } -> void
-
-  # Re-composes a prime factorization and returns the product.
-  #
-  # See Prime#int_from_prime_division for more details.
-  #
-  def self.from_prime_division: (Array[[ String ]]) -> Integer
-
-  # Returns the factorization of `self`.
-  #
-  # See Prime#prime_division for more details.
-  #
-  def prime_division: (?Prime::PseudoPrimeGenerator) -> Array[[ Integer, Integer ]]
-
-  # Returns true if `self` is a prime number, else returns false.
-  #
-  def prime?: () -> bool
-end

data/vendor/ruby-signature/stdlib/prime/prime.rbs

@@ -1,188 +0,0 @@
-# The set of all prime numbers.
-#
-# ## Example
-#
-#     Prime.each(100) do |prime|
-#       p prime  #=> 2, 3, 5, 7, 11, ...., 97
-#     end
-#
-# Prime is Enumerable:
-#
-#     Prime.first 5 # => [2, 3, 5, 7, 11]
-#
-# ## Retrieving the instance
-#
-# For convenience, each instance method of `Prime`.instance can be accessed as a
-# class method of `Prime`.
-#
-# e.g.
-#     Prime.instance.prime?(2)  #=> true
-#     Prime.prime?(2)           #=> true
-#
-# ## Generators
-#
-# A "generator" provides an implementation of enumerating pseudo-prime numbers
-# and it remembers the position of enumeration and upper bound. Furthermore, it
-# is an external iterator of prime enumeration which is compatible with an
-# Enumerator.
-#
-# `Prime`::`PseudoPrimeGenerator` is the base class for generators. There are
-# few implementations of generator.
-#
-# `Prime`::`EratosthenesGenerator`
-# :   Uses eratosthenes' sieve.
-# `Prime`::`TrialDivisionGenerator`
-# :   Uses the trial division method.
-# `Prime`::`Generator23`
-# :   Generates all positive integers which are not divisible by either 2 or 3.
-#     This sequence is very bad as a pseudo-prime sequence. But this is faster
-#     and uses much less memory than the other generators. So, it is suitable
-#     for factorizing an integer which is not large but has many prime factors.
-#     e.g. for Prime#prime? .
-#
-#
-class Prime
-  # Iterates the given block over all prime numbers.
-  #
-  # ## Parameters
-  #
-  # `ubound`
-  # :   Optional. An arbitrary positive number. The upper bound of enumeration.
-  #     The method enumerates prime numbers infinitely if `ubound` is nil.
-  # `generator`
-  # :   Optional. An implementation of pseudo-prime generator.
-  #
-  #
-  # ## Return value
-  #
-  # An evaluated value of the given block at the last time. Or an enumerator which
-  # is compatible to an `Enumerator` if no block given.
-  #
-  # ## Description
-  #
-  # Calls `block` once for each prime number, passing the prime as a parameter.
-  #
-  # `ubound`
-  # :   Upper bound of prime numbers. The iterator stops after it yields all prime
-  #     numbers p <= `ubound`.
-  #
-  def self?.each: (?Integer? ubound, ?PseudoPrimeGenerator generator) { (Integer) -> void } -> void
-                | (?Integer? ubound, ?PseudoPrimeGenerator generator) -> PseudoPrimeGenerator
-
-  # Re-composes a prime factorization and returns the product.
-  #
-  # ## Parameters
-  # `pd`
-  # :   Array of pairs of integers. The each internal pair consists of a prime
-  #     number -- a prime factor -- and a natural number -- an exponent.
-  #
-  #
-  # ## Example
-  # For `[[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]]`, it returns:
-  #
-  #     p_1**e_1 * p_2**e_2 * .... * p_n**e_n.
-  #
-  #     Prime.int_from_prime_division([[2,2], [3,1]])  #=> 12
-  #
-  def self?.int_from_prime_division: (Array[[ Integer, Integer ]]) -> Integer
-
-  # Returns true if `value` is a prime number, else returns false.
-  #
-  # ## Parameters
-  #
-  # `value`
-  # :   an arbitrary integer to be checked.
-  # `generator`
-  # :   optional. A pseudo-prime generator.
-  #
-  def self?.prime?: (Integer value, ?PseudoPrimeGenerator generator) -> bool
-
-  # Returns the factorization of `value`.
-  #
-  # ## Parameters
-  # `value`
-  # :   An arbitrary integer.
-  # `generator`
-  # :   Optional. A pseudo-prime generator. `generator`.succ must return the next
-  #     pseudo-prime number in the ascending order. It must generate all prime
-  #     numbers, but may also generate non prime numbers too.
-  #
-  #
-  # ### Exceptions
-  # `ZeroDivisionError`
-  # :   when `value` is zero.
-  #
-  #
-  # ## Example
-  # For an arbitrary integer:
-  #
-  #     n = p_1**e_1 * p_2**e_2 * .... * p_n**e_n,
-  #
-  # prime_division(n) returns:
-  #
-  #     [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]].
-  #
-  #     Prime.prime_division(12) #=> [[2,2], [3,1]]
-  #
-  def self?.prime_division: (Integer, ?PseudoPrimeGenerator generator) -> Array[[ Integer, Integer ]]
-
-  # Returns the singleton instance.
-  #
-  def self.instance: () -> Prime
-end
-
-# An abstract class for enumerating pseudo-prime numbers.
-#
-# Concrete subclasses should override succ, next, rewind.
-#
-class Prime::PseudoPrimeGenerator
-  def initialize: (?Integer?) -> void
-
-  include Enumerable[Integer, void]
-
-  attr_accessor upper_bound (): Integer?
-
-  # Iterates the given block for each prime number.
-  #
-  def each: () { (Integer) -> void } -> void
-
-  # alias of `succ`.
-  #
-  def next: () -> Integer
-
-  # Rewinds the internal position for enumeration.
-  #
-  # See `Enumerator`#rewind.
-  #
-  def rewind: () -> void
-
-  def size: () -> Float
-
-  # returns the next pseudo-prime number, and move the internal position forward.
-  #
-  # `PseudoPrimeGenerator`#succ raises `NotImplementedError`.
-  #
-  def succ: () -> Integer
-end
-
-# An implementation of `PseudoPrimeGenerator`.
-# 
-# Uses `EratosthenesSieve`.
-# 
-class Prime::EratosthenesGenerator < PseudoPrimeGenerator
-end
-
-# An implementation of `PseudoPrimeGenerator` which uses a prime table generated
-# by trial division.
-# 
-class Prime::TrialDivisionGenerator < PseudoPrimeGenerator
-end
-
-# Generates all integers which are greater than 2 and are not divisible by
-# either 2 or 3.
-# 
-# This is a pseudo-prime generator, suitable on checking primality of an integer
-# by brute force method.
-# 
-class Prime::Generator23 < PseudoPrimeGenerator
-end