# 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() 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_realpath(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));
    }