In Files

  • vm.c

Class/Module Index [+]

Quicksearch
toggle debugging

Thread::Backtrace::Location

An object representation of a stack frame, initialized by Kernel#caller_locations.

For example:

# caller_locations.rb
def a(skip)
  caller_locations(skip)
end
def b(skip)
  a(skip)
end
def c(skip)
  b(skip)
end

c(0..2).map do |call|
  puts call.to_s
end

Running ruby caller_locations.rb will produce:

caller_locations.rb:2:in `a'
caller_locations.rb:5:in `b'
caller_locations.rb:8:in `c'

Here’s another example with a slightly different result:

# foo.rb
class Foo
  attr_accessor :locations
  def initialize(skip)
    @locations = caller_locations(skip)
  end
end

Foo.new(0..2).locations.map do |call|
  puts call.to_s
end

Now run ruby foo.rb and you should see:

init.rb:4:in `initialize'
init.rb:8:in `new'
init.rb:8:in `<main>'

Public Instance Methods

absolute_path() click to toggle source

Returns the full file path of this frame.

Same as path, but includes the absolute path.

 
               static VALUE
location_absolute_path_m(VALUE self)
{
    return location_absolute_path(location_ptr(self));
}
            
base_label() click to toggle source

Returns the base label of this frame.

Usually same as label, without decoration.

 
               static VALUE
location_base_label_m(VALUE self)
{
    return location_base_label(location_ptr(self));
}
            
inspect() click to toggle source

Returns the same as calling inspect on the string representation of to_str

 
               static VALUE
location_inspect_m(VALUE self)
{
    return rb_str_inspect(location_to_str(location_ptr(self)));
}
            
label() click to toggle source

Returns the label of this frame.

Usually consists of method, class, module, etc names with decoration.

Consider the following example:

def foo
  puts caller_locations(0).first.label

  1.times do
    puts caller_locations(0).first.label

    1.times do
      puts caller_locations(0).first.label
    end

  end
end

The result of calling foo is this:

label: foo
label: block in foo
label: block (2 levels) in foo
 
               static VALUE
location_label_m(VALUE self)
{
    return location_label(location_ptr(self));
}
            
lineno() click to toggle source

Returns the line number of this frame.

For example, using caller_locations.rb from Thread::Backtrace::Location

loc = c(0..1).first
loc.lineno #=> 2
 
               static VALUE
location_lineno_m(VALUE self)
{
    return INT2FIX(location_lineno(location_ptr(self)));
}
            
path() click to toggle source

Returns the file name of this frame.

For example, using caller_locations.rb from Thread::Backtrace::Location

loc = c(0..1).first
loc.path #=> caller_locations.rb
 
               static VALUE
location_path_m(VALUE self)
{
    return location_path(location_ptr(self));
}
            
to_s() click to toggle source

Returns a Kernel#caller style string representing this frame.

 
               static VALUE
location_to_str_m(VALUE self)
{
    return location_to_str(location_ptr(self));
}
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus