steep 0.11.1 → 0.12.0

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

@@ -0,0 +1,248 @@
+# A `Module` is a collection of methods and constants. The methods in a
+# module may be instance methods or module methods. Instance methods
+# appear as methods in a class when the module is included, module methods
+# do not. Conversely, module methods may be called without creating an
+# encapsulating object, while instance methods may not. (See
+# `Module#module_function` .)
+# 
+# In the descriptions that follow, the parameter *sym* refers to a symbol,
+# which is either a quoted string or a `Symbol` (such as `:name` ).
+# 
+# ```ruby
+# module Mod
+#   include Math
+#   CONST = 1
+#   def meth
+#     #  ...
+#   end
+# end
+# Mod.class              #=> Module
+# Mod.constants          #=> [:CONST, :PI, :E]
+# Mod.instance_methods   #=> [:meth]
+# ```
+class Module < Object
+  # In the first form, returns an array of the names of all constants
+  # accessible from the point of call. This list includes the names of all
+  # modules and classes defined in the global scope.
+  # 
+  # ```ruby
+  # Module.constants.first(4)
+  #    # => [:ARGF, :ARGV, :ArgumentError, :Array]
+  # 
+  # Module.constants.include?(:SEEK_SET)   # => false
+  # 
+  # class IO
+  #   Module.constants.include?(:SEEK_SET) # => true
+  # end
+  # ```
+  # 
+  # The second form calls the instance method `constants` .
+  def self.constants: () -> ::Array[Integer]
+
+  # Returns the list of `Modules` nested at the point of call.
+  # 
+  # ```ruby
+  # module M1
+  #   module M2
+  #     $a = Module.nesting
+  #   end
+  # end
+  # $a           #=> [M1::M2, M1]
+  # $a[0].name   #=> "M1::M2"
+  # ```
+  def self.nesting: () -> ::Array[Module]
+
+  def self.used_modules: () -> ::Array[Module]
+
+  def <: (Module other) -> bool?
+
+  def <=: (Module other) -> bool?
+
+  def <=>: (Module other) -> Integer?
+
+  def ==: (untyped other) -> bool
+
+  def ===: (untyped other) -> bool
+
+  def >: (Module other) -> bool?
+
+  def >=: (Module other) -> bool?
+
+  def alias_method: (Symbol new_name, Symbol old_name) -> self
+
+  # Returns a list of modules included/prepended in *mod* (including *mod*
+  # itself).
+  # 
+  # ```ruby
+  # module Mod
+  #   include Math
+  #   include Comparable
+  #   prepend Enumerable
+  # end
+  # 
+  # Mod.ancestors        #=> [Enumerable, Mod, Comparable, Math]
+  # Math.ancestors       #=> [Math]
+  # Enumerable.ancestors #=> [Enumerable]
+  # ```
+  def ancestors: () -> ::Array[Module]
+
+  def append_features: (Module arg0) -> self
+
+  def `attr_accessor`: (*Symbol | String arg0) -> NilClass
+
+  def `attr_reader`: (*Symbol | String arg0) -> NilClass
+
+  def `attr_writer`: (*Symbol | String arg0) -> NilClass
+
+  def autoload: (Symbol _module, String filename) -> NilClass
+
+  def autoload?: (Symbol name) -> String?
+
+  def class_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
+                | [U] (untyped arg0) { (untyped m) -> U } -> U
+
+  def class_exec: (*untyped args) { () -> untyped } -> untyped
+
+  def class_variable_defined?: (Symbol | String arg0) -> bool
+
+  def class_variable_get: (Symbol | String arg0) -> untyped
+
+  def class_variable_set: (Symbol | String arg0, untyped arg1) -> untyped
+
+  def class_variables: (?bool inherit) -> ::Array[Symbol]
+
+  def const_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+
+  def const_get: (Symbol | String arg0, ?bool inherit) -> untyped
+
+  def const_missing: (Symbol arg0) -> untyped
+
+  def const_set: (Symbol | String arg0, untyped arg1) -> untyped
+
+  def constants: (?bool inherit) -> ::Array[Symbol]
+
+  def define_method: (Symbol | String arg0, ?Proc | Method | UnboundMethod arg1) -> Symbol
+                   | (Symbol | String arg0) { () -> untyped } -> Symbol
+
+  def eql?: (untyped other) -> bool
+
+  def equal?: (untyped other) -> bool
+
+  def extend_object: (untyped arg0) -> untyped
+
+  def extended: (Module othermod) -> untyped
+
+  # Prevents further modifications to *mod* .
+  # 
+  # This method returns self.
+  def freeze: () -> self
+
+  def `include`: (*Module arg0) -> self
+
+  def `include?`: (Module arg0) -> bool
+
+  def included: (Module othermod) -> untyped
+
+  # Returns the list of modules included in *mod* .
+  # 
+  # ```ruby
+  # module Mixin
+  # end
+  # 
+  # module Outer
+  #   include Mixin
+  # end
+  # 
+  # Mixin.included_modules   #=> []
+  # Outer.included_modules   #=> [Mixin]
+  # ```
+  def included_modules: () -> ::Array[Module]
+
+  def initialize: () -> Object
+                | () { (Module arg0) -> untyped } -> void
+
+  def instance_method: (Symbol arg0) -> UnboundMethod
+
+  def instance_methods: (?bool include_super) -> ::Array[Symbol]
+
+  def method_added: (Symbol meth) -> untyped
+
+  def method_defined?: (Symbol | String arg0) -> bool
+
+  def method_removed: (Symbol method_name) -> untyped
+
+  def module_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
+                 | [U] (untyped arg0) { (untyped m) -> U } -> U
+
+  def module_exec: (*untyped args) { () -> untyped } -> untyped
+
+  def module_function: (*Symbol | String arg0) -> self
+
+  # Returns the name of the module *mod* . Returns nil for anonymous
+  # modules.
+  def name: () -> String?
+
+  def `prepend`: (*Module arg0) -> self
+
+  def prepend_features: (Module arg0) -> self
+
+  def prepended: (Module othermod) -> untyped
+
+  def `private`: (*Symbol | String arg0) -> self
+
+  def private_class_method: (*Symbol | String arg0) -> self
+
+  def private_constant: (*Symbol arg0) -> self
+
+  def private_instance_methods: (?bool include_super) -> ::Array[Symbol]
+
+  def private_method_defined?: (Symbol | String arg0) -> bool
+
+  def protected: (*Symbol | String arg0) -> self
+
+  def protected_instance_methods: (?bool include_super) -> ::Array[Symbol]
+
+  def protected_method_defined?: (Symbol | String arg0) -> bool
+
+  def `public`: (*Symbol | String arg0) -> self
+
+  def public_class_method: (*Symbol | String arg0) -> self
+
+  def public_constant: (*Symbol arg0) -> self
+
+  def public_instance_method: (Symbol arg0) -> UnboundMethod
+
+  def public_instance_methods: (?bool include_super) -> ::Array[Symbol]
+
+  def public_method_defined?: (Symbol | String arg0) -> bool
+
+  def refine: (Class arg0) { (untyped arg0) -> untyped } -> self
+
+  def remove_class_variable: (Symbol arg0) -> untyped
+
+  def remove_const: (Symbol arg0) -> untyped
+
+  def remove_method: (Symbol | String arg0) -> self
+
+  # Returns `true` if *mod* is a singleton class or `false` if it is an
+  # ordinary class or module.
+  # 
+  # ```ruby
+  # class C
+  # end
+  # C.singleton_class?                  #=> false
+  # C.singleton_class.singleton_class?  #=> true
+  # ```
+  def `singleton_class?`: () -> bool
+
+  def to_s: () -> String
+
+  def undefMethod: (Symbol | String arg0) -> self
+
+  def using: (Module arg0) -> self
+
+  # Alias for: [to\_s](Module.downloaded.ruby_doc#method-i-to_s)
+  def inspect: () -> String
+
+  def attr: (*Symbol | String arg0) -> NilClass
+end

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

@@ -0,0 +1,82 @@
+# The class of the singleton object `nil`.
+# 
+class NilClass
+  public
+
+  # And---Returns `false`. *obj* is always evaluated as it is the argument to a
+  # method call---there is no short-circuit evaluation in this case.
+  # 
+  def &: (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 ===: (nil) -> true
+         | (untyped obj) -> bool
+
+  # Dummy pattern matching -- always returns nil.
+  # 
+  def =~: (untyped obj) -> nil
+
+  # Exclusive Or---If *obj* is `nil` or `false`, returns `false`; otherwise,
+  # returns `true`.
+  # 
+  def ^: (nil) -> false
+       | (false) -> false
+       | (untyped obj) -> bool
+
+  # Always returns the string "nil".
+  # 
+  def inspect: () -> "nil"
+
+  # Only the object *nil* responds `true` to `nil?`.
+  # 
+  def nil?: () -> bool
+
+  # Returns zero as a rational.  The optional argument `eps` is always ignored.
+  # 
+  def rationalize: (?untyped eps) -> Rational
+
+  # Always returns an empty array.
+  # 
+  #     nil.to_a   #=> []
+  # 
+  def to_a: () -> [ ]
+
+  # Returns zero as a complex.
+  # 
+  def to_c: () -> Complex
+
+  # Always returns zero.
+  # 
+  #     nil.to_f   #=> 0.0
+  # 
+  def to_f: () -> Float
+
+  # Always returns an empty hash.
+  # 
+  #     nil.to_h   #=> {}
+  # 
+  def to_h: () -> ::Hash[untyped, untyped]
+
+  # Always returns zero.
+  # 
+  #     nil.to_i   #=> 0
+  # 
+  def to_i: () -> 0
+
+  # Returns zero as a rational.
+  # 
+  def to_r: () -> Rational
+
+  # Always returns the empty string.
+  # 
+  def to_s: () -> ""
+
+  # Or---Returns `false` if *obj* is `nil` or `false`; `true` otherwise.
+  # 
+  def |: (nil) -> false
+       | (false) -> false
+       | (untyped obj) -> bool
+end

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

@@ -0,0 +1,409 @@
+# Numeric is the class from which all higher-level numeric classes should
+# inherit.
+# 
+# Numeric allows instantiation of heap-allocated objects. Other core numeric
+# classes such as Integer are implemented as immediates, which means that each
+# Integer is a single immutable object which is always passed by value.
+# 
+#     a = 1
+#     1.object_id == a.object_id   #=> true
+# 
+# There can only ever be one instance of the integer `1`, for example. Ruby
+# ensures this by preventing instantiation. If duplication is attempted, the
+# same instance is returned.
+# 
+#     Integer.new(1)                   #=> NoMethodError: undefined method `new' for Integer:Class
+#     1.dup                            #=> 1
+#     1.object_id == 1.dup.object_id   #=> true
+# 
+# For this reason, Numeric should be used when defining other numeric classes.
+# 
+# Classes which inherit from Numeric must implement `coerce`, which returns a
+# two-member Array containing an object that has been coerced into an instance
+# of the new class and `self` (see #coerce).
+# 
+# Inheriting classes should also implement arithmetic operator methods (`+`,
+# `-`, `*` and `/`) and the `<=>` operator (see Comparable). These methods may
+# rely on `coerce` to ensure interoperability with instances of other numeric
+# classes.
+# 
+#     class Tally < Numeric
+#       def initialize(string)
+#         @string = string
+#       end
+# 
+#       def to_s
+#         @string
+#       end
+# 
+#       def to_i
+#         @string.size
+#       end
+# 
+#       def coerce(other)
+#         [self.class.new('|' * other.to_i), self]
+#       end
+# 
+#       def <=>(other)
+#         to_i <=> other.to_i
+#       end
+# 
+#       def +(other)
+#         self.class.new('|' * (to_i + other.to_i))
+#       end
+# 
+#       def -(other)
+#         self.class.new('|' * (to_i - other.to_i))
+#       end
+# 
+#       def *(other)
+#         self.class.new('|' * (to_i * other.to_i))
+#       end
+# 
+#       def /(other)
+#         self.class.new('|' * (to_i / other.to_i))
+#       end
+#     end
+# 
+#     tally = Tally.new('||')
+#     puts tally * 2            #=> "||||"
+#     puts tally > 1            #=> true
+# 
+class Numeric
+  include Comparable
+
+  public
+
+  # `x.modulo(y)` means `x-y*(x/y).floor`.
+  # 
+  # Equivalent to `num.divmod(numeric)[1]`.
+  # 
+  # See Numeric#divmod.
+  # 
+  def %: (Numeric) -> Numeric
+
+  # Unary Plus---Returns the receiver.
+  # 
+  def +@: () -> Numeric
+
+  # Unary Minus---Returns the receiver, negated.
+  # 
+  def -@: () -> Numeric
+
+  # Returns zero if `number` equals `other`, otherwise returns `nil`.
+  # 
+  def <=>: (Numeric other) -> Integer
+
+  # Returns the absolute value of `num`.
+  # 
+  #     12.abs         #=> 12
+  #     (-34.56).abs   #=> 34.56
+  #     -34.56.abs     #=> 34.56
+  # 
+  # Numeric#magnitude is an alias for Numeric#abs.
+  # 
+  def abs: () -> Numeric
+
+  # Returns square of self.
+  # 
+  def abs2: () -> Numeric
+
+  # Returns 0 if the value is positive, pi otherwise.
+  # 
+  def angle: () -> Numeric
+
+  # Returns 0 if the value is positive, pi otherwise.
+  # 
+  alias arg angle
+
+  # Returns the smallest number greater than or equal to `num` with a precision of
+  # `ndigits` decimal digits (default: 0).
+  # 
+  # Numeric implements this by converting its value to a Float and invoking
+  # Float#ceil.
+  # 
+  def ceil: () -> Integer
+          | (Integer digits) -> (Integer | Numeric)
+
+  # If `numeric` is the same type as `num`, returns an array `[numeric, num]`.
+  # Otherwise, returns an array with both `numeric` and `num` represented as Float
+  # objects.
+  # 
+  # This coercion mechanism is used by Ruby to handle mixed-type numeric
+  # operations: it is intended to find a compatible common type between the two
+  # operands of the operator.
+  # 
+  #     1.coerce(2.5)   #=> [2.5, 1.0]
+  #     1.2.coerce(3)   #=> [3.0, 1.2]
+  #     1.coerce(2)     #=> [2, 1]
+  # 
+  def coerce: (Numeric) -> [ Numeric, Numeric ]
+
+  # Returns self.
+  # 
+  def conj: () -> Numeric
+
+  # Returns self.
+  # 
+  def conjugate: () -> Numeric
+
+  # Returns the denominator (always positive).
+  # 
+  def denominator: () -> Integer
+
+  # Uses `/` to perform division, then converts the result to an integer. Numeric
+  # does not define the `/` operator; this is left to subclasses.
+  # 
+  # Equivalent to `num.divmod(numeric)[0]`.
+  # 
+  # See Numeric#divmod.
+  # 
+  def div: (Numeric) -> Integer
+
+  # Returns an array containing the quotient and modulus obtained by dividing
+  # `num` by `numeric`.
+  # 
+  # If `q, r = x.divmod(y)`, then
+  # 
+  #     q = floor(x/y)
+  #     x = q*y + r
+  # 
+  # The quotient is rounded toward negative infinity, as shown in the following
+  # table:
+  # 
+  #      a    |  b  |  a.divmod(b)  |   a/b   | a.modulo(b) | a.remainder(b)
+  #     ------+-----+---------------+---------+-------------+---------------
+  #      13   |  4  |   3,    1     |   3     |    1        |     1
+  #     ------+-----+---------------+---------+-------------+---------------
+  #      13   | -4  |  -4,   -3     |  -4     |   -3        |     1
+  #     ------+-----+---------------+---------+-------------+---------------
+  #     -13   |  4  |  -4,    3     |  -4     |    3        |    -1
+  #     ------+-----+---------------+---------+-------------+---------------
+  #     -13   | -4  |   3,   -1     |   3     |   -1        |    -1
+  #     ------+-----+---------------+---------+-------------+---------------
+  #      11.5 |  4  |   2,    3.5   |   2.875 |    3.5      |     3.5
+  #     ------+-----+---------------+---------+-------------+---------------
+  #      11.5 | -4  |  -3,   -0.5   |  -2.875 |   -0.5      |     3.5
+  #     ------+-----+---------------+---------+-------------+---------------
+  #     -11.5 |  4  |  -3,    0.5   |  -2.875 |    0.5      |    -3.5
+  #     ------+-----+---------------+---------+-------------+---------------
+  #     -11.5 | -4  |   2,   -3.5   |   2.875 |   -3.5      |    -3.5
+  # 
+  # Examples
+  # 
+  #     11.divmod(3)        #=> [3, 2]
+  #     11.divmod(-3)       #=> [-4, -1]
+  #     11.divmod(3.5)      #=> [3, 0.5]
+  #     (-11).divmod(3.5)   #=> [-4, 3.0]
+  #     11.5.divmod(3.5)    #=> [3, 1.0]
+  # 
+  def divmod: (Numeric) -> [ Numeric, Numeric ]
+
+  # Returns `true` if `num` and `numeric` are the same type and have equal values.
+  #  Contrast this with Numeric#==, which performs type conversions.
+  # 
+  #     1 == 1.0        #=> true
+  #     1.eql?(1.0)     #=> false
+  #     1.0.eql?(1.0)   #=> true
+  # 
+  def eql?: (untyped) -> bool
+
+  # Returns float division.
+  # 
+  def fdiv: (Numeric) -> Numeric
+
+  # Returns `true` if `num` is a finite number, otherwise returns `false`.
+  # 
+  def finite?: () -> bool
+
+  # Returns the largest number less than or equal to `num` with a precision of
+  # `ndigits` decimal digits (default: 0).
+  # 
+  # Numeric implements this by converting its value to a Float and invoking
+  # Float#floor.
+  # 
+  def floor: () -> Integer
+           | (Integer digits) -> Numeric
+
+  # Returns the corresponding imaginary number. Not available for complex numbers.
+  # 
+  #     -42.i  #=> (0-42i)
+  #     2.0.i  #=> (0+2.0i)
+  # 
+  def i: () -> Complex
+
+  # Returns zero.
+  # 
+  def imag: () -> Numeric
+
+  # Returns zero.
+  # 
+  def imaginary: () -> Numeric
+
+  # Returns `nil`, -1, or 1 depending on whether the value is finite, `-Infinity`,
+  # or `+Infinity`.
+  # 
+  def infinite?: () -> Integer?
+
+  # Returns `true` if `num` is an Integer.
+  # 
+  #     1.0.integer?   #=> false
+  #     1.integer?     #=> true
+  # 
+  def integer?: () -> bool
+
+  # Returns the absolute value of `num`.
+  # 
+  #     12.abs         #=> 12
+  #     (-34.56).abs   #=> 34.56
+  #     -34.56.abs     #=> 34.56
+  # 
+  # Numeric#magnitude is an alias for Numeric#abs.
+  # 
+  alias magnitude abs
+
+  # `x.modulo(y)` means `x-y*(x/y).floor`.
+  # 
+  # Equivalent to `num.divmod(numeric)[1]`.
+  # 
+  # See Numeric#divmod.
+  # 
+  def modulo: (Numeric) -> Numeric
+
+  # Returns `true` if `num` is less than 0.
+  # 
+  def negative?: () -> bool
+
+  # Returns `self` if `num` is not zero, `nil` otherwise.
+  # 
+  # This behavior is useful when chaining comparisons:
+  # 
+  #     a = %w( z Bb bB bb BB a aA Aa AA A )
+  #     b = a.sort {|a,b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
+  #     b   #=> ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]
+  # 
+  def nonzero?: () -> self?
+
+  # Returns the numerator.
+  # 
+  def numerator: () -> Numeric
+
+  # Returns 0 if the value is positive, pi otherwise.
+  # 
+  alias phase angle
+
+  # Returns an array; [num.abs, num.arg].
+  # 
+  def polar: () -> [ Numeric, Numeric ]
+
+  # Returns `true` if `num` is greater than 0.
+  # 
+  def positive?: () -> bool
+
+  # Returns the most exact division (rational for integers, float for floats).
+  # 
+  def quo: (Numeric) -> Numeric
+
+  # Returns self.
+  # 
+  def real: () -> Numeric
+
+  # Returns `true` if `num` is a real number (i.e. not Complex).
+  # 
+  def real?: () -> bool
+
+  # Returns an array; [num, 0].
+  # 
+  def rect: () -> [ Numeric, Numeric ]
+
+  # Returns an array; [num, 0].
+  # 
+  alias rectangular rect
+
+  # `x.remainder(y)` means `x-y*(x/y).truncate`.
+  # 
+  # See Numeric#divmod.
+  # 
+  def remainder: (Numeric) -> Numeric
+
+  # Returns `num` rounded to the nearest value with a precision of `ndigits`
+  # decimal digits (default: 0).
+  # 
+  # Numeric implements this by converting its value to a Float and invoking
+  # Float#round.
+  # 
+  def round: () -> Integer
+           | (Integer digits) -> Numeric
+
+  # Invokes the given block with the sequence of numbers starting at `num`,
+  # incremented by `step` (defaulted to `1`) on each call.
+  # 
+  # The loop finishes when the value to be passed to the block is greater than
+  # `limit` (if `step` is positive) or less than `limit` (if `step` is negative),
+  # where `limit` is defaulted to infinity.
+  # 
+  # In the recommended keyword argument style, either or both of `step` and
+  # `limit` (default infinity) can be omitted.  In the fixed position argument
+  # style, zero as a step (i.e. `num.step(limit, 0)`) is not allowed for
+  # historical compatibility reasons.
+  # 
+  # If all the arguments are integers, the loop operates using an integer counter.
+  # 
+  # If any of the arguments are floating point numbers, all are converted to
+  # floats, and the loop is executed *floor(n + n*Float::EPSILON) + 1* times,
+  # where *n = (limit - num)/step*.
+  # 
+  # Otherwise, the loop starts at `num`, uses either the less-than (`<`) or
+  # greater-than (`>`) operator to compare the counter against `limit`, and
+  # increments itself using the `+` operator.
+  # 
+  # If no block is given, an Enumerator is returned instead. Especially, the
+  # enumerator is an Enumerator::ArithmeticSequence if both `limit` and `step` are
+  # kind of Numeric or `nil`.
+  # 
+  # For example:
+  # 
+  #     p 1.step.take(4)
+  #     p 10.step(by: -1).take(4)
+  #     3.step(to: 5) {|i| print i, " " }
+  #     1.step(10, 2) {|i| print i, " " }
+  #     Math::E.step(to: Math::PI, by: 0.2) {|f| print f, " " }
+  # 
+  # Will produce:
+  # 
+  #     [1, 2, 3, 4]
+  #     [10, 9, 8, 7]
+  #     3 4 5
+  #     1 3 5 7 9
+  #     2.718281828459045 2.9182818284590453 3.118281828459045
+  # 
+  def step: (?Numeric limit, ?Numeric step) { (Numeric) -> void } -> self
+          | (?Numeric limit, ?Numeric step) -> Enumerator[Numeric, self]
+          | (?by: Numeric, ?to: Numeric) { (Numeric) -> void } -> self
+          | (?by: Numeric, ?to: Numeric) -> Enumerator[Numeric, self]
+
+  # Returns the value as a complex.
+  # 
+  def to_c: () -> Complex
+
+  # Invokes the child class's `to_i` method to convert `num` to an integer.
+  # 
+  #     1.0.class          #=> Float
+  #     1.0.to_int.class   #=> Integer
+  #     1.0.to_i.class     #=> Integer
+  # 
+  def to_int: () -> Integer
+
+  # Returns `num` truncated (toward zero) to a precision of `ndigits` decimal
+  # digits (default: 0).
+  # 
+  # Numeric implements this by converting its value to a Float and invoking
+  # Float#truncate.
+  # 
+  def truncate: () -> Integer
+              | (Integer ndigits) -> (Integer | Numeric)
+
+  # Returns `true` if `num` has a zero value.
+  # 
+  def zero?: () -> bool
+end