steep 0.14.0 → 0.15.0

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

@@ -1,91 +1,290 @@
+# Document-class: TracePoint
+#
+# A class that provides the functionality of Kernel#set_trace_func in a nice
+# Object-Oriented API.
+#
+# ## Example
+#
+# We can use TracePoint to gather information specifically for exceptions:
+#
+#     trace = TracePoint.new(:raise) do |tp|
+#         p [tp.lineno, tp.event, tp.raised_exception]
+#     end
+#     #=> #<TracePoint:disabled>
+#
+#     trace.enable
+#     #=> false
+#
+#     0 / 0
+#     #=> [5, :raise, #<ZeroDivisionError: divided by 0>]
+#
+# ## Events
+#
+# If you don't specify the type of events you want to listen for, TracePoint
+# will include all available events.
+#
+# **Note** do not depend on current event set, as this list is subject to
+# change. Instead, it is recommended you specify the type of events you want to
+# use.
+#
+# To filter what is traced, you can pass any of the following as `events`:
+#
+# `:line`
+# :   execute code on a new line
+# `:class`
+# :   start a class or module definition
+# `:end`
+# :   finish a class or module definition
+# `:call`
+# :   call a Ruby method
+# `:return`
+# :   return from a Ruby method
+# `:c_call`
+# :   call a C-language routine
+# `:c_return`
+# :   return from a C-language routine
+# `:raise`
+# :   raise an exception
+# `:b_call`
+# :   event hook at block entry
+# `:b_return`
+# :   event hook at block ending
+# `:thread_begin`
+# :   event hook at thread beginning
+# `:thread_end`
+# :   event hook at thread ending
+# `:fiber_switch`
+# :   event hook at fiber switch
+# `:script_compiled`
+# :   new Ruby code compiled (with `eval`, `load` or `require`)
+#
+#
 class TracePoint < Object
+  # Returns a new TracePoint object, not enabled by default.
+  #
+  # Next, in order to activate the trace, you must use TracePoint#enable
+  #
+  #     trace = TracePoint.new(:call) do |tp|
+  #         p [tp.lineno, tp.defined_class, tp.method_id, tp.event]
+  #     end
+  #     #=> #<TracePoint:disabled>
+  #
+  #     trace.enable
+  #     #=> false
+  #
+  #     puts "Hello, TracePoint!"
+  #     # ...
+  #     # [48, IRB::Notifier::AbstractNotifier, :printf, :call]
+  #     # ...
+  #
+  # When you want to deactivate the trace, you must use TracePoint#disable
+  #
+  #     trace.disable
+  #
+  # See TracePoint@Events for possible events and more information.
+  #
+  # A block must be given, otherwise an ArgumentError is raised.
+  #
+  # If the trace method isn't included in the given events filter, a RuntimeError
+  # is raised.
+  #
+  #     TracePoint.trace(:line) do |tp|
+  #         p tp.raised_exception
+  #     end
+  #     #=> RuntimeError: 'raised_exception' not supported by this event
+  #
+  # If the trace method is called outside block, a RuntimeError is raised.
+  #
+  #     TracePoint.trace(:line) do |tp|
+  #       $tp = tp
+  #     end
+  #     $tp.lineno #=> access from outside (RuntimeError)
+  #
+  # Access from other threads is also forbidden.
+  #
   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.
+  # Returns internal information of TracePoint.
+  #
+  # The contents of the returned value are implementation specific. It may be
+  # changed in future.
+  #
+  # This method is only for debugging TracePoint itself.
+  #
   def self.stat: () -> untyped
 
+  # Document-method: trace
+  #
+  #     A convenience method for TracePoint.new, that activates the trace
+  #     automatically.
+  #
+  #            trace = TracePoint.trace(:call) { |tp| [tp.lineno, tp.event] }
+  #            #=> #<TracePoint:enabled>
+  #
+  #            trace.enabled? #=> true
+  #
   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
+  # Return class or module of the method being called.
+  #
+  #     class C; def foo; end; end
+  #     trace = TracePoint.new(:call) do |tp|
+  #       p tp.defined_class #=> C
+  #     end.enable do
+  #       C.new.foo
+  #     end
+  #
+  # If method is defined by a module, then that module is returned.
+  #
+  #     module M; def foo; end; end
+  #     class C; include M; end;
+  #     trace = TracePoint.new(:call) do |tp|
+  #       p tp.defined_class #=> M
+  #     end.enable do
+  #       C.new.foo
+  #     end
+  #
+  # **Note:** #defined_class returns singleton class.
+  #
+  # 6th block parameter of Kernel#set_trace_func passes original class of attached
+  # by singleton class.
+  #
+  # **This is a difference between Kernel#set_trace_func and TracePoint.**
+  #
+  #     class C; def self.foo; end; end
+  #     trace = TracePoint.new(:call) do |tp|
+  #       p tp.defined_class #=> #<Class:C>
+  #     end.enable do
+  #       C.foo
+  #     end
+  #
+  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?      #=> 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.
+  #
   #     trace.enabled?
-  #     # only disabled for this block
-  # end
-  # 
-  # trace.enabled?
-  # #=> true
-  # ```
-  # 
+  #     #=> 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
-  # ```
+  #
+  #     trace.disable { p tp.lineno }
+  #     #=> RuntimeError: access from outside
+  #
   def disable: () -> bool
              | () { () -> void } -> void
 
+  # Activates the trace.
+  #
+  # Returns `true` if trace was enabled. Returns `false` if trace was disabled.
+  #
+  #     trace.enabled?  #=> false
+  #     trace.enable    #=> false (previous state)
+  #                     #   trace is enabled
+  #     trace.enabled?  #=> true
+  #     trace.enable    #=> true (previous state)
+  #                     #   trace is still enabled
+  #
+  # If a block is given, the trace will only be enabled within the scope of the
+  # block.
+  #
+  #     trace.enabled?
+  #     #=> false
+  #
+  #     trace.enable do
+  #       trace.enabled?
+  #       # only enabled for this block
+  #     end
+  #
+  #     trace.enabled?
+  #     #=> false
+  #
+  # `target`, `target_line` and `target_thread` parameters are used to limit
+  # tracing only to specified code objects. `target` should be a code object for
+  # which RubyVM::InstructionSequence.of will return an instruction sequence.
+  #
+  #     t = TracePoint.new(:line) { |tp| p tp }
+  #
+  #     def m1
+  #       p 1
+  #     end
+  #
+  #     def m2
+  #       p 2
+  #     end
+  #
+  #     t.enable(target: method(:m1))
+  #
+  #     m1
+  #     # prints #<TracePoint:line@test.rb:5 in `m1'>
+  #     m2
+  #     # prints nothing
+  #
+  # Note: You cannot access event hooks within the `enable` block.
+  #
+  #     trace.enable { p tp.lineno }
+  #     #=> RuntimeError: access from outside
+  #
   def enable: () -> bool
             | () { () -> void } -> void
 
   # The current status of the trace
+  #
   def enabled?: () -> bool
 
+  # Return a string containing a human-readable TracePoint status.
+  #
   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')
-  # ```
+  #
+  # Same as TracePoint#binding:
+  #     trace.binding.eval('self')
+  #
   def `self`: () -> Binding
 end

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

@@ -1,64 +1,58 @@
-# 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
-# ```
+# Ruby supports two forms of objectified methods. Class 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.
+#
+#     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.
+#
+#     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.
-  # 
+  # 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
@@ -82,78 +76,78 @@ class UnboundMethod
   #     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
-  # ```
-  # 
+  # Bind *umeth* to *obj*. If Klass was the class from which *umeth* was obtained,
+  # `obj.kind_of?(Klass)` must be true.
+  #
+  #     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
-  # ```
+  # Returns the class or module that defines the method. See also Method#receiver.
+  #
+  #     (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 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).
+  # 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.
+  # Returns a Method 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/coverage/coverage.rbs

@@ -0,0 +1,62 @@
+# Coverage provides coverage measurement feature for Ruby. This feature is
+# experimental, so these APIs may be changed in future.
+#
+# # Usage
+#
+# 1.  require "coverage"
+# 2.  do Coverage.start
+# 3.  require or load Ruby source file
+# 4.  Coverage.result will return a hash that contains filename as key and
+#     coverage array as value. A coverage array gives, for each line, the number
+#     of line execution by the interpreter. A `nil` value means coverage is
+#     disabled for this line (lines like `else` and `end`).
+#
+#
+# # Example
+#
+#     [foo.rb]
+#     s = 0
+#     10.times do |x|
+#       s += x
+#     end
+#
+#     if s == 45
+#       p :ok
+#     else
+#       p :ng
+#     end
+#     [EOF]
+#
+#     require "coverage"
+#     Coverage.start
+#     require "foo.rb"
+#     p Coverage.result  #=> {"foo.rb"=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}
+#
+module Coverage
+  def self.line_stub: () -> Array[Integer?]
+
+  # Returns a hash that contains filename as key and coverage array as value. This
+  # is the same as `Coverage.result(stop: false, clear: false)`.
+  #
+  #     {
+  #       "file.rb" => [1, 2, nil],
+  #       ...
+  #     }
+  #
+  def self.peek_result: () -> Hash[String, untyped]
+
+  # Returns a hash that contains filename as key and coverage array as value. If
+  # `clear` is true, it clears the counters to zero. If `stop` is true, it
+  # disables coverage measurement.
+  #
+  def self.result: (?stop: bool, ?clear: bool) -> Hash[String, untyped]
+
+  # Returns true if coverage stats are currently being collected (after
+  # Coverage.start call, but before Coverage.result call)
+  #
+  def self.running?: () -> bool
+
+  # Enables coverage measurement.
+  #
+  def self.start: (?lines: bool, ?branches: bool, ?methods: bool, ?oneshot_lines: bool) -> nil
+end