class Byebug::Frame


Represents a frame in the stack trace

def _binding 

def _binding
  @context.frame_binding(pos)
end

def _class 

def _class
  @context.frame_class(pos)
end

def _method 

def _method
  @context.frame_method(pos)
end

def _self 

def _self
  @context.frame_self(pos)
end

def args


Gets current method arguments for the frame.
def args
  return c_args unless _binding
  ruby_args
end

def c_args 

def c_args
  return [] unless _self.to_s != 'main'
  _self.method(_method).parameters
end

def c_frame?


Checks whether the frame is a c-frame
def c_frame?
  _binding.nil?
end

def current? 

def current?
  @context.frame.pos == pos
end

def deco_args


setting
verbose or non verbose way according to the value of the +callstyle+
Builds a string containing all available args in the frame number, in a
def deco_args
  return '' if args.empty?
  my_args = args.map do |arg|
    prefix, default = prefix_and_default(arg[0])
    kls = use_short_style?(arg) ? '' : "##{locals[arg[1]].class}"
    "#{prefix}#{arg[1] || default}#{kls}"
  end
  "(#{my_args.join(', ')})"
end

def deco_block 

def deco_block
  _method[/(?:block(?: \(\d+ levels\))?|rescue) in /] || ''
end

def deco_call


Builds a formatted string containing information about current method call
def deco_call
  deco_block + deco_class + deco_method + deco_args
end

def deco_class


+callstyle+ setting is 'short'
Returns the current class in the frame or an empty string if the current
def deco_class
  Setting[:callstyle] == 'short' || _class.to_s.empty? ? '' : "#{_class}."
end

def deco_file


Formatted filename in frame
def deco_file
  Setting[:fullpath] ? File.expand_path(file) : shortpath(file)
end

def deco_method 

def deco_method
  _method[/((?:block(?: \(\d+ levels\))?|rescue) in )?(.*)/]
end

def deco_pos


Properly formatted frame number of frame
def deco_pos
  format('%-2d', pos)
end

def file 

def file
  @context.frame_file(pos)
end

def initialize(context, pos) 

def initialize(context, pos)
  @context = context
  @pos = pos
end

def line 

def line
  @context.frame_line(pos)
end

def locals


TODO: Use brand new local_variable_{get,set,defined?} for rubies >= 2.1

Gets local variables for the frame.
def locals
  return [] unless _binding
  _binding.eval('local_variables.inject({}){|h, v| h[v] = eval(v.to_s); h}')
end

def mark


marks regular frames
ͱ-- marks c-frames
--> marks the current frame

Formatted mark for the frame.
def mark
  return '-->' if current?
  return '    ͱ--' if c_frame?
  '   '
end

def prefix_and_default(arg_type) 

def prefix_and_default(arg_type)
  return ['&', 'block'] if arg_type == :block
  return ['*', 'args'] if arg_type == :rest
  ['', nil]
end

def ruby_args 

def ruby_args
  return [] unless _binding.eval('__method__')
  return [] unless _binding.eval('method(__method__)')
  _binding.eval('method(__method__).parameters')
end

def to_hash 

def to_hash
  {
    mark: mark,
    pos: deco_pos,
    call: deco_call,
    file: deco_file,
    line: line,
    full_path: File.expand_path(deco_file)
  }
end

def use_short_style?(arg) 

def use_short_style?(arg)
  Setting[:callstyle] == 'short' || arg[1].nil? || locals.empty?
end