Gecko [ www.beriskala.com ]

Name	Size	Permission	Date
enumerator	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
io	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
object_space	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
rbs	[ DIR ]	drwxr-xr-x	2026-04-07 16:50
rubygems	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
array.rbs	137.79 KB	-rw-r--r--	2026-04-07 16:50
basic_object.rbs	12.57 KB	-rw-r--r--	2026-04-07 16:50
binding.rbs	4.11 KB	-rw-r--r--	2026-04-07 16:50
builtin.rbs	7.29 KB	-rw-r--r--	2026-04-07 16:50
class.rbs	6.72 KB	-rw-r--r--	2026-04-07 16:51
comparable.rbs	5.63 KB	-rw-r--r--	2026-04-07 16:50
complex.rbs	25.1 KB	-rw-r--r--	2026-04-07 16:50
constants.rbs	1.89 KB	-rw-r--r--	2026-04-07 16:50
data.rbs	12.7 KB	-rw-r--r--	2026-04-07 16:50
dir.rbs	31.49 KB	-rw-r--r--	2026-04-07 16:50
encoding.rbs	46.41 KB	-rw-r--r--	2026-04-07 16:50
enumerable.rbs	85.7 KB	-rw-r--r--	2026-04-07 16:50
enumerator.rbs	19.37 KB	-rw-r--r--	2026-04-07 16:50
env.rbs	159 B	-rw-r--r--	2026-04-07 16:51
errno.rbs	10.71 KB	-rw-r--r--	2026-04-07 16:50
errors.rbs	18.81 KB	-rw-r--r--	2026-04-07 16:51
exception.rbs	11.58 KB	-rw-r--r--	2026-04-07 16:50
false_class.rbs	2.1 KB	-rw-r--r--	2026-04-07 16:50
fiber.rbs	19.11 KB	-rw-r--r--	2026-04-07 16:50
fiber_error.rbs	374 B	-rw-r--r--	2026-04-07 16:50
file.rbs	92.57 KB	-rw-r--r--	2026-04-07 16:50
file_test.rbs	10.2 KB	-rw-r--r--	2026-04-07 16:50
float.rbs	32.78 KB	-rw-r--r--	2026-04-07 16:50
gc.rbs	20.88 KB	-rw-r--r--	2026-04-07 16:50
global_variables.rbs	5.64 KB	-rw-r--r--	2026-04-07 16:50
hash.rbs	58.89 KB	-rw-r--r--	2026-04-07 16:50
integer.rbs	40.51 KB	-rw-r--r--	2026-04-07 16:51
io.rbs	112.18 KB	-rw-r--r--	2026-04-07 16:50
kernel.rbs	104.83 KB	-rw-r--r--	2026-04-07 16:50
marshal.rbs	7.07 KB	-rw-r--r--	2026-04-07 16:50
match_data.rbs	19.65 KB	-rw-r--r--	2026-04-07 16:50
math.rbs	20.28 KB	-rw-r--r--	2026-04-07 16:50
method.rbs	11.59 KB	-rw-r--r--	2026-04-07 16:50
module.rbs	54.2 KB	-rw-r--r--	2026-04-07 16:50
nil_class.rbs	3.97 KB	-rw-r--r--	2026-04-07 16:51
numeric.rbs	23.7 KB	-rw-r--r--	2026-04-07 16:50
object.rbs	5.03 KB	-rw-r--r--	2026-04-07 16:50
object_space.rbs	6.14 KB	-rw-r--r--	2026-04-07 16:51
proc.rbs	29.73 KB	-rw-r--r--	2026-04-07 16:50
process.rbs	77.15 KB	-rw-r--r--	2026-04-07 16:50
ractor.rbs	32.03 KB	-rw-r--r--	2026-04-07 16:50
random.rbs	7.85 KB	-rw-r--r--	2026-04-07 16:51
range.rbs	34.28 KB	-rw-r--r--	2026-04-07 16:50
rational.rbs	14.96 KB	-rw-r--r--	2026-04-07 16:50
rb_config.rbs	2.9 KB	-rw-r--r--	2026-04-07 16:50
refinement.rbs	1.42 KB	-rw-r--r--	2026-04-07 16:51
regexp.rbs	66.72 KB	-rw-r--r--	2026-04-07 16:50
ruby_vm.rbs	23.15 KB	-rw-r--r--	2026-04-07 16:51
set.rbs	19.36 KB	-rw-r--r--	2026-04-07 16:50
signal.rbs	3.59 KB	-rw-r--r--	2026-04-07 16:50
string.rbs	119.45 KB	-rw-r--r--	2026-04-07 16:51
struct.rbs	22.73 KB	-rw-r--r--	2026-04-07 16:51
symbol.rbs	12.96 KB	-rw-r--r--	2026-04-07 16:51
thread.rbs	51.52 KB	-rw-r--r--	2026-04-07 16:51
thread_group.rbs	2.35 KB	-rw-r--r--	2026-04-07 16:50
time.rbs	59.56 KB	-rw-r--r--	2026-04-07 16:50
trace_point.rbs	12.85 KB	-rw-r--r--	2026-04-07 16:50
true_class.rbs	2.23 KB	-rw-r--r--	2026-04-07 16:50
unbound_method.rbs	9.97 KB	-rw-r--r--	2026-04-07 16:50
warning.rbs	2.56 KB	-rw-r--r--	2026-04-07 16:50

Rename

# 
# A class that provides the functionality of Kernel#set_trace_func in a
# well-structured Object-Oriented API.
#
# ## Example
#
# 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 types of events you want to listen for, TracePoint
# will include all available events.
#
# **Note:** Do not depend on the current event set, as this list is subject to
# change. Instead, it is recommended to specify the types of events you want to
# use.
#
# To filter what is traced, you can pass any of the following as `events`:
#
# `:line`
# :   Execute an expression or statement 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.
#
# `:rescue`
# :   Rescue an exception.
#
# `:b_call`
# :   Event hook at block entry.
#
# `:b_return`
# :   Event hook at block ending.
#
# `:a_call`
# :   Event hook at all calls (`call`, `b_call`, and `c_call`).
#
# `:a_return`
# :   Event hook at all returns (`return`, `b_return`, and `c_return`).
#
# `: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
  # 
  # Returns a new TracePoint object, not enabled by default.
  #
  # To activate the TracePoint object, 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]
  #     # ...
  #
  # To deactivate the trace, 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 a 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 self.new: (*_ToSym events) { (instance tp) -> void } -> instance

# 
  # Generally, while a TracePoint callback is running, other registered callbacks
  # are not called to avoid confusion from reentrance. This method allows
  # reentrance within a given block. Use this method carefully to avoid infinite
  # callback invocation.
  #
  # If called when reentrance is already allowed, it raises a RuntimeError.
  #
  # **Example:**
  #
  #     # Without reentry
  #     # ---------------
  #
  #     line_handler = TracePoint.new(:line) do |tp|
  #       next if tp.path != __FILE__ # Only works in this file
  #       puts "Line handler"
  #       binding.eval("class C; end")
  #     end.enable
  #
  #     class_handler = TracePoint.new(:class) do |tp|
  #       puts "Class handler"
  #     end.enable
  #
  #     class B
  #     end
  #
  #     # This script will print "Class handler" only once: when inside the :line
  #     # handler, all other handlers are ignored.
  #
  #     # With reentry
  #     # ------------
  #
  #     line_handler = TracePoint.new(:line) do |tp|
  #       next if tp.path != __FILE__ # Only works in this file
  #       next if (__LINE__..__LINE__+3).cover?(tp.lineno) # Prevent infinite calls
  #       puts "Line handler"
  #       TracePoint.allow_reentry { binding.eval("class C; end") }
  #     end.enable
  #
  #     class_handler = TracePoint.new(:class) do |tp|
  #       puts "Class handler"
  #     end.enable
  #
  #     class B
  #     end
  #
  #     # This will print "Class handler" twice: inside the allow_reentry block in the :line
  #     # handler, other handlers are enabled.
  #
  # Note that the example shows the principal effect of the method, but its
  # practical usage is for debugging libraries that sometimes require other
  # libraries' hooks to not be affected by the debugger being inside trace point
  # handling. Precautions should be taken against infinite recursion in this case
  # (note that we needed to filter out calls by itself from the :line handler,
  # otherwise it would call itself infinitely).
  #
  def self.allow_reentry: [T] () { (nil) -> T } -> T

# 
  # Returns internal information of TracePoint.
  #
  # The contents of the returned value are implementation-specific and may change
  # in the future.
  #
  # This method is only for debugging TracePoint itself.
  #
  def self.stat: () -> untyped

# 
  # 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: (*_ToSym events) { (instance tp) -> void } -> instance

# 
  # Returns the generated binding object from the event.
  #
  # Note that for `:c_call` and `:c_return` events, the method returns `nil`,
  # since C methods themselves do not have bindings.
  #
  def binding: () -> Binding?

# 
  # Returns the called name of the method being called.
  #
  def callee_id: () -> Symbol?

# 
  # Returns the 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 the 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 the singleton class.
  #
  # The 6th block parameter of Kernel#set_trace_func passes the original class
  # attached by the 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: () -> (Class | Module)?

# 
  # Deactivates the trace.
  #
  # Returns `true` if the trace was enabled. Returns `false` if the trace was
  # disabled.
  #
  #     trace.enabled?  #=> true
  #     trace.disable   #=> true (previous status)
  #     trace.enabled?  #=> false
  #     trace.disable   #=> false
  #
  # If a block is given, the trace will only be disabled within the scope of the
  # block.
  #
  #     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.
  #
  #     trace.disable { p tp.lineno }
  #     #=> RuntimeError: access from outside
  #
  def disable: () -> bool
             | [T] () { () -> T } -> T

# 
  # Activates the trace.
  #
  # Returns `true` if the trace was enabled. Returns `false` if the 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 during the block
  # execution. If target and target_line are both nil, then target_thread will
  # default to the current thread if a block is given.
  #
  #     trace.enabled?  #=> false
  #
  #     trace.enable do
  #       trace.enabled?
  #       # Only enabled for this block and thread
  #     end
  #
  #     trace.enabled?  #=> false
  #
  # The `target`, `target_line`, and `target_thread` parameters are used to limit
  # tracing 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:4 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: (?target: Method | UnboundMethod | RubyVM::InstructionSequence | Proc | nil, ?target_line: int?, ?target_thread: Thread | :default | nil) -> bool
            | [T] (?target: Method | UnboundMethod | RubyVM::InstructionSequence | Proc | nil, ?target_line: int?, ?target_thread: Thread | :default | nil) { () -> T } -> T

# 
  # Returns the current status of the trace.
  #
  def enabled?: () -> bool

# 
  # Returns the type of event.
  #
  # See TracePoint@Events for more information.
  #
  def event: () -> ::Symbol

# 
  # Returns a string containing a human-readable TracePoint status.
  #
  def inspect: () -> String

# 
  # Returns the line number of the event.
  #
  def lineno: () -> Integer

# 
  # Returns the name at the definition of the method being called.
  #
  def method_id: () -> Symbol?

# 
  # Returns the path of the file being executed.
  #
  def path: () -> String

# 
  # Returns the parameter definitions of the method or block that the current hook
  # belongs to. The format is the same as for Method#parameters.
  #
  def parameters: () -> Method::param_types?

# 
  # Returns the exception raised on the `:raise` event or rescued on the `:rescue`
  # event.
  #
  def raised_exception: () -> Exception

# 
  # Returns the return value from `:return`, `:c_return`, and `:b_return` events.
  #
  def return_value: () -> untyped

# 
  # Returns the trace object during the event.
  #
  # Similar to the following, but it returns the correct object (the method
  # receiver) for `:c_call` and `:c_return` events:
  #
  #     trace.binding.eval('self')
  #
  def self: () -> untyped

# 
  # Returns the compiled source code (String) from eval methods on the
  # `:script_compiled` event. If loaded from a file, it returns `nil`.
  #
  def eval_script: () -> String?

# 
  # Returns the compiled instruction sequence represented by a
  # RubyVM::InstructionSequence instance on the `:script_compiled` event.
  #
  # Note that this method is CRuby-specific.
  #
  def instruction_sequence: () -> RubyVM::InstructionSequence
end