Add tests for new YARD::Logger behavior

lib/yard/logging.rb

@@ -201,7 +201,7 @@ def add(code = :warn, opts = {}, _progname = nil)
       end
 
       opts = {:message => opts} if String === opts
-      message = block_given? ? yield.strip.squeeze : opts[:message]
+      message = block_given? ? clean_block_message(yield) : opts[:message]
       message ||= ""
 
       if Hash === code
@@ -256,6 +256,10 @@ def call_log_callbacks(code, message, severity, opts, list)
       should_log
     end
 
+    def clean_block_message(message)
+      message.gsub(/\n +/, "\n").strip
+    end
+
     def clear_line
       return unless @progress_msg
       print_no_newline("\e[2K\r")

spec/logging_spec.rb

@@ -33,4 +33,138 @@
       log.enter_level(Logger::INFO) { log.backtrace(exc, :warn) }
     end
   end
+
+  describe "#add" do
+    before do
+      @callbacks = YARD::Logger.on_message_callbacks
+      @codes = YARD::Logger.codes
+      @calls = []
+      @expect_calls = []
+    end
+
+    after do
+      YARD::Logger.codes.clear.replace(@codes)
+      YARD::Logger.on_message_callbacks.clear.replace(@callbacks)
+      expect(@calls).to eq(@expect_calls) unless @expect_calls.empty?
+    end
+
+    def expect_called(code)
+      @expect_calls << code
+      YARD::Logger.on_message(code) { @calls << code }
+    end
+
+    it 'can use severities for code' do
+      log.add(:warn) { 'message' }
+      expect(log.io.string).to match(/warn.*message/)
+    end
+
+    it 'allows 2nd param to be a string' do
+      log.add :warn, 'message'
+      expect(log.io.string).to match(/warn.*message/)
+    end
+
+    it 'allows 1st param to be a hash' do
+      log.add(:code => :warn, :object => 'data') { 'message' }
+      expect(log.io.string).to match(/warn.*message/)
+    end
+
+    it 'allows :message to be in opts' do
+      log.add(:warn, :object => 'data') { 'message' }
+      expect(log.io.string).to match(/warn.*message/)
+    end
+
+    it 'allows empty message' do
+      expect_called(:warn)
+      log.add :warn
+    end
+
+    it 'raises if code is not supplied in code, msg form' do
+      expect { log.add(nil, 'message') }.to raise_error(ArgumentError)
+    end
+
+    it 'raises if code is not supplied in opts form' do
+      expect { log.add({}) }.to raise_error(ArgumentError)
+    end
+
+    it 'strips extra space from message in block' do
+      log.add :warn do
+        <<-eof
+        MESSAGE
+        ONE
+        TWO
+          \tTHREE
+        eof
+      end
+      expect(log.io.string).to match("[warn]: MESSAGE\nONE\nTWO\n\tTHREE\n")
+    end
+
+    it 'calls callback for code' do
+      YARD::Logger.register_code :test_code, :error
+      expect_called(:test_code)
+      log.add :test_code, 'message'
+    end
+
+    it 'passes options data to callback' do
+      YARD::Logger.register_code :test_code, :warn
+
+      called = false
+      YARD::Logger.on_message :test_code do |data|
+        called = true
+        expect(data[:message]).to eq 'message'
+        expect(data[:code]).to eq :test_code
+        expect(data[:severity]).to eq :warn
+        expect(data[:object]).to eq 'object'
+      end
+
+      log.add :test_code, :object => 'object' do
+        'message'
+      end
+      expect(called).to eq true
+    end
+
+    it 'still calls callback for severity' do
+      YARD::Logger.register_code :test_code, :error
+      expect_called(:error)
+      log.add :test_code, 'message'
+    end
+
+    it 'always calls catch-all callback' do
+      YARD::Logger.register_code :test_code, :error
+      expect_called(nil)
+      log.add :test_code, 'message'
+    end
+
+    it 'can suppress a log message in a callback' do
+      YARD::Logger.register_code :test_code, :warn
+      YARD::Logger.on_message :test_code do
+        raise YARD::Logger::SuppressMessage
+      end
+
+      called = false
+      YARD::Logger.on_message(:warn) { called = true }
+
+      log.add :test_code, 'message'
+      expect(log.io.string).to be_empty
+      expect(called).to eq false
+    end
+
+    it 'calls all callback at a given level when suppressing' do
+      YARD::Logger.register_code :test_code, :warn
+      YARD::Logger.on_message(:test_code) { log.io.print 'a' }
+      YARD::Logger.on_message(:test_code) { raise YARD::Logger::SuppressMessage }
+      YARD::Logger.on_message(:test_code) { log.io.print 'b' }
+      YARD::Logger.on_message(:test_code) { log.io.print 'c' }
+
+      log.add :test_code, 'message'
+      expect(log.io.string).to eq 'abc'
+    end
+
+    it 'debugs a warning (before logging code) if unknown code is used' do
+      log.enter_level(Logger::DEBUG) do
+        log.add :unknown_code, '!!message!!'
+        expect(log.io.string).to match(/logging warning for unknown code: unknown_code/)
+        expect(log.io.string).to match(/!!message!!/)
+      end
+    end
+  end
 end