# class 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 ()
Source

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

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.

base_label ()
Source

    static VALUE
    location_base_label_m(VALUE self)
    {
        return location_base_label(location_ptr(self));
    }

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

inspect ()
Source

    static VALUE
    location_inspect_m(VALUE self)
    {
        return rb_str_inspect(location_to_str(location_ptr(self)));
    }

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

label ()
Source

    static VALUE
    location_label_m(VALUE self)
    {
        return location_label(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:

    foo
    block in foo
    block (2 levels) in foo

lineno ()
Source

    static VALUE
    location_lineno_m(VALUE self)
    {
        return INT2FIX(location_lineno(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

path ()
Source

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

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 #=> caller_locations.rb

to_s ()
Source

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

Returns a `Kernel#caller` style string representing this frame.