Class: PowerAssert::Context

# File 'lib/power_assert/context.rb', line 10

def initialize(base_caller_length)
  @fired = false
  @target_thread = Thread.current
  method_id_set = nil
  @return_values = []
  @trace_return = TracePoint.new(:return, :c_return) do |tp|
    unless method_id_set
      next unless Thread.current == @target_thread
      method_id_set = @parser.method_id_set
    end
    method_id = tp.callee_id
    next if ! method_id_set[method_id]
    next if tp.event == :c_return and
            not (@parser.lineno == tp.lineno and @parser.path == tp.path)
    locs = PowerAssert.app_caller_locations
    diff = locs.length - base_caller_length
    if (tp.event == :c_return && diff == 1 || tp.event == :return && diff <= 2) and Thread.current == @target_thread
      idx = -(base_caller_length + 1)
      if @parser.path == locs[idx].path and @parser.lineno == locs[idx].lineno
        val = PowerAssert.configuration.lazy_inspection ?
          tp.return_value :
          InspectedValue.new(SafeInspectable.new(tp.return_value).inspect)
        @return_values << Value[method_id.to_s, val, locs[idx].lineno, nil]
      end
    end
  rescue Exception => e
    warn "power_assert: [BUG] Failed to trace: #{e.class}: #{e.message}"
    if e.respond_to?(:full_message)
      warn e.full_message.gsub(/^/, 'power_assert:     ')
    end
  end
end

# File 'lib/power_assert/context.rb', line 54

def fired?
  @fired
end

# File 'lib/power_assert/context.rb', line 58

def build_assertion_message(parser, return_values)
  if PowerAssert.configuration.colorize_message
    line = IRB::Color.colorize_code(parser.line, ignore_error: true)
  else
    line = parser.line
  end

  path = detect_path(parser, return_values)
  return line unless path

  c2d = column2display_offset(parser.line)
  return_values, methods_in_path = find_all_identified_calls(return_values, path)
  return_values.zip(methods_in_path) do |i, j|
    unless i.name == j.name
      warn "power_assert: [BUG] Failed to get column: #{i.name}"
      return line
    end
    i.display_offset = c2d[j.column]
  end
  refs_in_path = path.find_all {|i| i.type == :ref }
  ref_values = refs_in_path.map {|i| Value[i.name, parser.binding.eval(i.name), parser.lineno, i.column, c2d[i.column]] }
  vals = (return_values + ref_values).find_all(&:display_offset).sort_by(&:display_offset).reverse
  return line if vals.empty?

  fmt = (0..vals[0].display_offset).map do |i|
    if vals.find {|v| v.display_offset == i }
      "%<#{i}>s"
    else
      line[i] == "\t" ? "\t" : ' '
    end
  end.join
  lines = []
  lines << line.chomp
  lines << sprintf(fmt, vals.each_with_object({}) {|v, h| h[:"#{v.display_offset}"] = '|' }).chomp
  vals.each do |i|
    inspected_val = SafeInspectable.new(Inspector.new(i.value, i.display_offset)).inspect
    inspected_val.each_line do |l|
      map_to = vals.each_with_object({}) do |j, h|
        h[:"#{j.display_offset}"] = [l, '|', ' '][i.display_offset <=> j.display_offset]
      end
      lines << encoding_safe_rstrip(sprintf(fmt, map_to))
    end
  end
  lines.join("\n")
end