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_alias_method = PowerAssert.configuration._trace_alias_method
  @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 = SUPPORT_ALIAS_METHOD                      ? tp.callee_id :
                trace_alias_method && tp.event == :return ? tp.binding.eval('::Kernel.__callee__') :
                                                            tp.method_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
  end
end

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

def fired?
  @fired
end

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

def build_assertion_message(parser, return_values)
  if PowerAssert.configuration._colorize_message
    line = Pry::Code.new(parser.line).highlighted
  else
    line = parser.line
  end

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

  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.column = 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] }
  vals = (return_values + ref_values).find_all(&:column).sort_by(&:column).reverse
  return line if vals.empty?

  fmt = (0..vals[0].column).map do |i|
    if vals.find {|v| v.column == 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.column.to_s.to_sym] = '|' }).chomp
  vals.each do |i|
    inspected_val = SafeInspectable.new(Formatter.new(i.value, i.column)).inspect
    inspected_val.each_line do |l|
      map_to = vals.each_with_object({}) do |j, h|
        h[j.column.to_s.to_sym] = [l, '|', ' '][i.column <=> j.column]
      end
      lines << encoding_safe_rstrip(sprintf(fmt, map_to))
    end
  end
  lines.join("\n")
end