easy-going-rails/lib/formatters/ansi_formatter.rb

require_relative 'ansi_wrapper'
require_relative 'ansi_colors'
require_relative 'ansi_dimensions'

require 'io/console'
require 'amazing_print'
require 'json'

# wraps meanwhile takes care of ansi colors
class AnsiFormatter < SemanticLogger::Formatters::Color
  include AnsiColors

  CENTER_SIZE = 20
  FOREMAN_PREFIX_LENGTH = 18
  FAILOVER_WRAP = 80
  CHAR_FATAL = '⯶'.freeze
  TERMINUS_STRING = '╙─╜'.freeze
  RENDERED_VIEW_DURATION = 100
  TOTAL_RENDERED_VIEW_DURATION = RENDERED_VIEW_DURATION * 5

  def initialize
    super(color_map:
      ColorMap.new(
        debug: CLEAR + TEXT_GRAY_400,
        info: CLEAR + TEXT_GRAY_100,
        warn: CLEAR + BG_YELLOW + TEXT_BLACK,
        error: CLEAR + BG_RED + TEXT_WHITE,
        fatal: CLEAR + BG_MAGENTA + BOLD + TEXT_WHITE
      ))
    @memory = nil
  end

  def call(log, logger)
    @regex_redirected ||= build_regex_redirected # called once when Rails gets ready!
    log = alter(log)

    self.log = log
    self.logger = logger
    self.color = color_map[log.level]

    wrap_level(compute_useful_length, message, payload, exception)
  end

  def reject(log)
    return true if log.name == 'ActionView::Base' && log.message&.starts_with?('  Rendering')

    true if log.name == 'Rails' && log.message&.starts_with?('Loaded')
  end

  private

  def build_regex_redirected
    dev_port = Rails.application.routes.default_url_options[:port]
    dev_hosts = ['127.0.0.1', 'localhost', Rails.application.routes.default_url_options[:host]].uniq.join('|')
    dev_from = "http://(?:#{dev_hosts}):#{dev_port}"
    regex_s = "^(Redirected to )#{dev_from}(.*)"
    Regexp.new(regex_s)
  end

  def ansi_trace(trace, symbol)
    match = trace.match(/(↳ )?(.*:\d+)(:in `)?(.*'?)/) # only m2(=file) and m4(=optional function) are useful
    return trace unless match

    _, m2, _, m4 = match.captures
    "#{symbol} #{m2} #{BOLD}#{m4.chop}#{CLEAR}"
  end

  def two_captures_last_as_bold(message, regex)
    match = message.match(regex)
    return "unmatched: #{message}" unless match

    m1, m2 = match.captures
    "#{m1}#{BOLD}#{m2}#{CLEAR}"
  end

  def alter(log)
    if log.name == 'Rails'
      if log.message
        log.message.lstrip!
        log.message.chomp!('')
        if log.message.starts_with?('Started')
          rails = '╓─╖'
          before = 1
          if @memory
            rails = "╓#{@memory}╖"
            before = 0
          end
          log.dimensions = AnsiDimensions.new(rails:, before:)
          @memory = nil
          log.message = two_captures_last_as_bold(log.message, /(^Started \w* )"(.*?)"/)
        elsif log.message.starts_with?('Parameters')
          parameters = log.message.match(/Parameters: ({.*}$)/).match(1)
          parameters = JSON.parse(parameters.gsub('=>', ':'), symbolize_names: true)
          parameters = parameters.ai(ruby19_syntax: true, plain: true, multiline: false)
          parameters = parameters.gsub(/\w*:/) { |key| "#{TEXT_GRAY_200}#{key.chop}#{color_map[:debug]}:" }
          parameters = parameters.gsub(/: ".*?"/) do |value|
            ": \"#{TEXT_YELLOW}#{value[3..-2]}#{color_map[:debug]}\""
          end
          log.message = "Parameters: #{parameters}"
          log.level = :debug
        elsif log.message.starts_with?('Completed')
          m1, m2, m3, m4 = log.message.match(/^Completed (\d+) (.*) in (\d+\.?\d*)ms (.*)$/).captures
          http_code = m1.to_i
          duration = m3.to_f
          duration = duration > TOTAL_RENDERED_VIEW_DURATION ? " in #{m3}ms #{m4}" : ''
          log.message = "Completed #{BOLD}#{http_code}#{CLEAR} #{m2}#{duration}"
          if http_code / 100 == 2
            log.dimensions = AnsiDimensions.new(rails: TERMINUS_STRING, after: 1)
          elsif http_code / 100 == 3
            @memory = '║'
            log.dimensions = AnsiDimensions.new(rails: "╙#{@memory}╜")
          elsif http_code / 100 == 4
            log.dimensions = AnsiDimensions.new(rails: '╙╨╜')
          elsif http_code / 100 == 5
            log.dimensions = AnsiDimensions.new(rails: "╙#{draw_fatal}╜")
          end
        elsif log.message =~ /^(Processing|Parameters)/
          log.level = :debug
          if log.message =~ /^Processing/
            log.message = two_captures_last_as_bold(log.message, /(^Processing by \w*#\w* as )(.*)/)
          end
        elsif log.message =~ /Redirected/
          log.level = :debug
          log.message = two_captures_last_as_bold(log.message, @regex_redirected)
        end
      elsif log.exception
        log.dimensions = AnsiDimensions.new(
          rails: "╓#{draw_fatal(log.level.to_s.chr.upcase)}╖",
          after: 1,
          terminus: true
        )
      end
    elsif log.name =~ /^(ActionView|ActiveRecord)::Base/
      log.level = :debug
      log.message.lstrip!
      if log.name == 'ActiveRecord::Base'
        unbold!(log.message)

        if log.message.starts_with?('↳ ')
          log.message = ansi_trace(log.message, '⇄')
        else
          sql_match = log.message.match(/\s+\[\[.*\]\]$/)
          if sql_match
            sql_command = sql_match.pre_match
            sql_type, sql_entry = sql_command.split("\e[0m")
            sql_color_entry = sql_entry.match(ANSI_REGEX).to_s
            sql_args = JSON.parse(sql_match.to_s).map(&:last)
            sql_args.each_with_index do |val, index|
              sql_arg = val.inspect
              sql_arg = "'#{val.gsub("'", "''")}'" if val.is_a?(String)
              sql_entry.gsub!("$#{index + 1}", colorize(sql_arg, BOLD) + sql_color_entry)
            end
            log.message = [sql_type, sql_entry].join(CLEAR)
          end
        end
      elsif log.name == 'ActionView::Base'
        match = log.message.match(/^Rendered( layout| collection of|) (.*?\.erb)(.*)(\(Duration:.*\))/)
        if match
          m1, m2, m3, m4 = match.captures
          duration = m4.match(/Duration: (\d+\.?\d*)ms/).match(1).to_f
          duration = duration < RENDERED_VIEW_DURATION ? '' : m4.to_s
          log.message = "⇤ Rendered#{m1} app/views/#{m2}#{m3}#{duration}"
        end
      end

    end

    log
  end

  def draw_fatal(char = CHAR_FATAL)
    BG_MAGENTA + BOLD + TEXT_WHITE + char + CLEAR
  end

  def origin                          = colorize(centerize(log.name), TEXT_CYAN)
  def build_prefix(char)              = "#{origin} ╣#{colorize(char)}╠  "
  def build_terminus                  = "#{origin} #{TERMINUS_STRING}  "
  def centerize(text)                 = text.truncate(CENTER_SIZE).center(CENTER_SIZE)
  def colorize(text, tint = color)    = "#{tint}#{text}#{CLEAR}"

  def stackisize(items)
    return '' if items.empty?

    traces = items.map { |item| ansi_trace(item, '➟') }
    "\n#{traces.join("\n")}"
  end

  def build_dimensions(dimensions)
    "#{origin} #{dimensions.rails}  "
  end

  def compute_useful_length
    IO.console.winsize[1] - FOREMAN_PREFIX_LENGTH
  rescue StandardError
    FAILOVER_WRAP
  end

  def unbold!(text) = text.gsub!(BOLD, '')

  def message
    colorize(log.message) if log.message
  end

  def payload
    return unless log.payload

    log.payload.ai(indent: 2, object_id: false)
  end

  def exception
    return unless log.exception

    exc = log.exception
    clazz = colorize("#{exc.class}\n", color_map[:fatal])
    message = colorize(exc.message.chomp(''), color_map[:error])
    backtrace = stackisize(Rails.backtrace_cleaner.clean(exc.backtrace))

    "#{clazz}#{message}#{backtrace}"
  end

  def level_char
    case log.level
    when :info, :debug then ' '
    else log.level.to_s.chr.upcase
    end
  end

  def wrap_level(length, *items)
    prefix = log.dimensions ? build_dimensions(log.dimensions) : build_prefix(level_char)
    continuation = build_prefix('┆')

    result = items.map do |item|
      AnsiWrapper.wrap(item, length, prefix, continuation)
    end

    if log.dimensions&.terminus
      terminus = AnsiWrapper.wrap(' ', length, build_terminus)
      result << terminus
    end

    log.dimensions&.before&.times { result.unshift('') }
    log.dimensions&.after&.times { result << '' }
    result.compact.join("\n")
  end
end