class Thread::Backtrace::Location - RDoc Documentation (original) (raw)

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

For example:

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:

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 `

'

Public Instance Methods

absolute_path() click to toggle source

Returns the full file path of this frame.

Same as path, except that it will return absolute path even if the frame is in the main script.

static VALUE location_absolute_path_m(VALUE self) { return location_realpath(location_ptr(self)); }

base_label() click to toggle source

Returns the base label of this frame, which is usually equal to the label, without decoration.

Consider the following example:

def foo puts caller_locations(0).first.base_label

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

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

end end

The result of calling foo is this:

foo foo foo

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:

foo block in foo 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

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. This will generally be an absolute path, unless the frame is in the main script, in which case it will be the script location passed on the command line.

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

loc = c(0..1).first loc.path

static VALUE location_path_m(VALUE self) { const rb_iseq_t *iseq = location_iseq(location_ptr(self)); return iseq ? rb_iseq_path(iseq) : Qnil; }

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)); }