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>'
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_realpath(location_ptr(self)); }
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)); }
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))); }
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)); }
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))); }
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)); }
Returns a Kernel#caller
style string representing this frame.
static VALUE location_to_str_m(VALUE self) { return location_to_str(location_ptr(self)); }