steep 0.11.1 → 0.12.0

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

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

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

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

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

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

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

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

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

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