new-logger-api-proposal.rb

# frozen_string_literal: true
require_relative './lib/yard'

log.level = Logger::DEBUG

class CustomLogger < YARD::Logger
  class SuppressMessage < RuntimeError; end

  @@yard_log = YARD::Logger.instance

  def self.register_code(code, severity)
    codes[code] = severity
  end

  def self.codes
    @codes ||= {}
  end

  def self.on_message_callbacks
    @on_message_callbacks ||= {}
  end

  def self.on_message(code = nil, &block)
    (on_message_callbacks[code] ||= []) << block
  end

  CORE_SEVERITIES = {
    fatal: true,
    error: true,
    warn: true,
    info: true,
    debug: true,
    unknown: true
  }
  private_constant :CORE_SEVERITIES

  def add(code = :warn, opts = {}, _progname = nil)
    return super if Fixnum === code

    opts = {message: opts} if String === opts
    message = block_given? ? yield.strip.squeeze : opts[:message]
    message ||= ""

    if Hash === code
      opts = code
      code = opts[:code]
    end

    raise ArgumentError, "missing required code" if code.nil?

    if CORE_SEVERITIES[code]
      severity = code
    else
      severity = self.class.codes[code]
      if severity.nil?
        @@yard_log.debug "logging warning for unknown code: #{code}"
        severity = :warn
      end
    end

    if call_log_callbacks(code, message, severity, opts)
      @@yard_log.send(severity, message)
    end
  end

  [:debug, :warn, :error, :fatal, :info, :unknown].each do |sev|
    define_method(sev) do |msg = ""|
      super(msg) if call_log_callbacks(sev, msg, sev, {})
    end
  end

  private

  # @return [Boolean] whether to send the message through to logger
  def call_log_callbacks(code, message, severity, opts)
    opts = opts.merge(code: code, message: message, severity: severity)
    should_log = true

    [code, self.class.codes[code], nil].uniq.each do |type|
      self.class.on_message_callbacks.fetch(type, []).each do |cb|
        begin
          cb.call(opts)
        rescue SuppressMessage
          should_log = false
        end
      end
    end

    should_log
  end
end

class YARD::Logger
  def self.instance; @adv_instance ||= CustomLogger.new(STDOUT) end
end

# Register custom codes
CustomLogger.register_code :unknown_tag, :warn
CustomLogger.register_code :circular_ref_tag, :error

# Callbacks
CustomLogger.on_message :unknown_tag do |data|
  p "unknown_tag #{data}"
end

CustomLogger.on_message :warn do |data| # All warnings
  p "All warnings #{data}"
end

require 'rspec'

describe CustomLogger do
  it 'logs warnings' do
    log.warn "hello"

    log.add :unknown_tag, object: 'string' do
      "hello world!"
    end
    log.add :unknown_code, 'bye bye world'
  end
end