Class: Thread::Backtrace::Location (Ruby 2.3.4)

    In Files

    • vm.c

    Class/Module Index [+]

    Quicksearch

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