yell 1.3.0 → 1.4.0

data/lib/yell/silencer.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+module Yell #:nodoc:
+
+  # The +Yell::Silencer+ is your handly helper for stiping out unwanted log messages.
+  class Silencer
+
+    def initialize( *patterns )
+      @patterns = patterns.dup
+    end
+
+    # Add one or more patterns to the silencer
+    #
+    # @example
+    #   add( 'password' )
+    #   add( 'username', 'password' )
+    #
+    # @example Add regular expressions
+    #   add( /password/ )
+    #
+    # @return [Array] All set patterns
+    def add( *patterns )
+      @patterns = @patterns | patterns.compact
+    end
+
+    # Clears out all the messages that would match any defined pattern
+    #
+    # @example
+    #   silence('username', 'password')
+    #   #=> ['username]
+    #
+    # @return [Array<String>] The remaining messages
+    def silence( *messages )
+      messages.reject { |m| matches?(m) }
+    end
+
+    # Anything to silence at all?
+    #
+    # @return [Boolean] true or false
+    def silence?
+      @patterns.any?
+    end
+
+    # Get a pretty string
+    def inspect
+      "#<#{self.class.name} patterns: #{@patterns.inspect}>"
+    end
+
+    # @private
+    def patterns
+      @patterns
+    end
+
+
+    private
+
+    # Check if the provided message matches any of the defined patterns.
+    #
+    # @example
+    #   matches?('password')
+    #   #=> true
+    #
+    # @return [Boolean] true or false
+    def matches?( message )
+      @patterns.any? { |pattern| message.match(pattern) }
+    end
+
+  end
+end
+

data/lib/yell/version.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 module Yell #:nodoc:
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 
 end
 

data/spec/spec_helper.rb

@@ -3,12 +3,29 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 
 ENV['YELL_ENV'] = 'test'
 
-require 'yell'
-
-require 'rspec'
+require 'rspec/core'
+require 'rspec/expectations'
 require 'rr'
 require 'timecop'
 
+begin
+  require 'coveralls'
+
+  require 'simplecov'
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    add_filter 'spec'
+  end
+rescue LoadError
+  STDERR.puts "Not running coverage..."
+end
+
+require 'yell'
+
 RSpec.configure do |config|
   config.mock_framework = :rr
 
@@ -19,8 +36,7 @@ RSpec.configure do |config|
   end
 
   config.after do
-    # release time after each test
-    Timecop.return
+    Timecop.return # release time after each test
   end
 
 
@@ -30,9 +46,5 @@ RSpec.configure do |config|
     File.expand_path( "fixtures", File.dirname(__FILE__) )
   end
 
-  def datefile_filename( pattern = Yell::Adapters::Datefile::DefaultDatePattern )
-    fixture_path + "/test.#{Time.now.strftime(pattern)}.log"
-  end
-
 end
 

data/spec/yell/adapters/base_spec.rb

@@ -2,57 +2,40 @@ require 'spec_helper'
 
 describe Yell::Adapters::Base do
 
-  context "initialize with :level" do
-    before do
-      any_instance_of( Yell::Adapters::Base ) do |base|
-        mock( base ).level= :info
-      end
-    end
+  context "initialize" do
+    context ":level" do
+      let(:level) { Yell::Level.new(:warn) }
 
-    it "should set the level" do
-      Yell::Adapters::Base.new(:level => :info)
-    end
-  end
+      it "should set the level" do
+        adapter = Yell::Adapters::Base.new(:level => level)
 
-  context "insitialize with :block" do
-    context :level do
-      before do
-        any_instance_of( Yell::Adapters::Base ) do |base|
-          mock( base ).level= :info
-        end
+        expect(adapter.level).to eq(level)
       end
 
-      it "should set the level" do
-        Yell::Adapters::Base.new(:level => :info)
+      it "should set the level when block was given" do
+        adapter = Yell::Adapters::Base.new { |a| a.level = level }
+
+        expect(adapter.level).to eq(level)
       end
     end
   end
 
-  context :options do
-    let(:options) { {:my => :options} }
-    let(:adapter) { Yell::Adapters::Base.new(options) }
-
-    it { options.should == options }
-  end
-
-  context :write do
+  context "#write" do
     let(:logger) { Yell::Logger.new }
     subject { Yell::Adapters::Base.new(:level => 1) }
 
     it "should delegate :event to :write!" do
-      event = Yell::Event.new( logger, 1, "Hello World!" )
-
-      mock( subject ).write!( event )
+      event = Yell::Event.new(logger, 1, "Hello World!")
+      mock(subject).write!(event)
 
-      subject.write( event )
+      subject.write(event)
     end
 
     it "should not write when event does not have the right level" do
-      event = Yell::Event.new( logger, 0, "Hello World!" )
-
-      dont_allow( subject ).write!( event )
+      event = Yell::Event.new(logger, 0, "Hello World!")
+      dont_allow(subject).write!(event)
 
-      subject.write( event )
+      subject.write(event)
     end
   end
 

data/spec/yell/adapters/datefile_spec.rb

@@ -2,122 +2,165 @@ require 'spec_helper'
 
 describe Yell::Adapters::Datefile do
   let(:logger) { Yell::Logger.new }
+  let(:message) { "Hello World" }
+  let(:event) { Yell::Event.new(logger, 1, message) }
+
+  let(:today) { Time.now }
+  let(:tomorrow) { Time.now + 86400 }
+
   let(:filename) { fixture_path + '/test.log' }
-  let(:event) { Yell::Event.new(logger, 1, "Hello World") }
+  let(:today_filename) { fixture_path + "/test.#{today.strftime(Yell::Adapters::Datefile::DefaultDatePattern)}.log" }
+  let(:tomorrow_filename) { fixture_path + "/test.#{tomorrow.strftime(Yell::Adapters::Datefile::DefaultDatePattern)}.log" }
+
+  let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename, :format => "%m") }
 
   before do
-    Timecop.freeze( Time.now )
+    Timecop.freeze(today)
   end
 
   it { should be_kind_of Yell::Adapters::File }
 
-  describe :filename do
-    let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename, :symlink => false) }
+  describe "#write" do
+    let(:today_lines) { File.readlines(today_filename) }
 
-    it "should be replaced with date_pattern" do
-      adapter.write( event )
-
-      File.exist?(datefile_filename).should be_true
+    before do
+      adapter.write(event)
     end
 
-    it "should open file handle only once" do
-      mock( File ).open( datefile_filename, anything ) { File.new('/dev/null', 'w') }
+    it "should be output to filename with date pattern" do
+      expect(File.exist?(today_filename)).to be_true
 
-      adapter.write( event )
-      Timecop.freeze( Time.now + 10 ) { adapter.write(event) }
+      expect(today_lines.size).to eq(2) # includes header line
+      expect(today_lines.last).to match(message)
     end
 
-    context "rollover" do
-      let(:tomorrow) { Time.now + 86400 }
-      let(:tomorrow_datefile_filename) { fixture_path + "/test.#{tomorrow.strftime(Yell::Adapters::Datefile::DefaultDatePattern)}.log" }
+    it "should output to the same file" do
+      adapter.write(event)
 
-      it "should rotate when date has passed" do
-        mock( File ).open( datefile_filename, anything ) { File.new('/dev/null', 'w') }
-        adapter.write( event )
+      expect(File.exist?(today_filename)).to be_true
+      expect(today_lines.size).to eq(3) # includes header line
+    end
 
-        Timecop.freeze( tomorrow )
+    it "should not open file handle again" do
+      dont_allow(File).open(anything, anything)
 
-        mock( File ).open( tomorrow_datefile_filename, anything ) { File.new('/dev/null', 'w') }
-        adapter.write( event )
-      end
+      adapter.write(event)
     end
-  end
 
-  describe :keep do
-    let(:adapter) { Yell::Adapters::Datefile.new(:keep => 2, :filename => filename, :symlink => false, :date_pattern => "%M") }
+    context "on rollover" do
+      let(:tomorrow_lines) { File.readlines(tomorrow_filename) }
 
-    it "should keep the specified number or files upon rollover" do
-      adapter.write( event )
-      Dir[ fixture_path + '/*.log' ].size.should == 1
-
-      Timecop.freeze( Time.now + 60 ) do
-        adapter.write( event )
-        Dir[ fixture_path + '/*.log' ].size.should == 2
+      before do
+        Timecop.freeze(tomorrow) { adapter.write(event) }
       end
 
-      Timecop.freeze( Time.now + 120 ) do
-        adapter.write( event )
-        Dir[ fixture_path + '/*.log' ].size.should == 2
+      it "should rotate file" do
+        expect(File.exist?(tomorrow_filename)).to be_true
+
+        expect(tomorrow_lines.size).to eq(2) # includes header line
+        expect(tomorrow_lines.last).to match(message)
       end
     end
   end
 
-  describe :symlink do
-    let(:time) { Time.now }
-    before { Timecop.freeze(time) }
+  describe "#keep" do
+    before do
+      adapter.symlink = false # to not taint the Dir
+      adapter.keep = 2
+
+      adapter.write(event)
+    end
 
-    context "default (true)" do
-      let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename, :date_pattern => "%M") }
+    it "should keep the specified number or files upon rollover" do
+      expect(Dir[fixture_path + '/*.log'].size).to eq(1)
 
-      it "should create the sylink the original filename" do
-        adapter.write( event )
+      Timecop.freeze(tomorrow) { adapter.write(event) }
+      expect(Dir[fixture_path + '/*.log'].size).to eq(2)
 
-        File.symlink?( filename ).should be_true
-        File.readlink( filename ).should == datefile_filename(adapter.date_pattern)
+      Timecop.freeze(tomorrow + 86400 ) { adapter.write(event) }
+      expect(Dir[fixture_path + '/*.log'].size).to eq(2)
+    end
+  end
+
+  describe "#symlink" do
+    context "when true (default)" do
+      before do
+        adapter.write(event)
       end
 
-      it "should symlink upon rollover" do
-        adapter.write( event )
+      it "should be created on the original filename" do
+        expect(File.symlink?(filename)).to be_true
+        expect(File.readlink(filename)).to eq(today_filename)
+      end
 
-        Timecop.freeze( time + 120 ) do
-          adapter.write( event )
+      it "should be recreated upon rollover" do
+        Timecop.freeze(tomorrow) { adapter.write(event) }
 
-          File.symlink?( filename ).should be_true
-          File.readlink( filename ).should == datefile_filename(adapter.date_pattern)
-        end
+        expect(File.symlink?(filename)).to be_true
+        expect(File.readlink(filename)).to eq(tomorrow_filename)
       end
     end
 
-    context "when set to false" do
-      let(:adapter) { Yell::Adapters::Datefile.new(:symlink => false, :filename => filename, :date_pattern => "%M") }
+    context "when false" do
+      before do
+        adapter.symlink = false
+      end
 
       it "should not create the sylink the original filename" do
         adapter.write( event )
 
-        File.symlink?( filename ).should be_false
+        expect(File.symlink?(filename)).to be_false
       end
     end
   end
 
-  describe :header do
-    let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename) }
-    let(:header) { File.open(datefile_filename, &:readline) }
+  describe "#header" do
+    let(:header) { File.open(today_filename, &:readline) }
 
-    before do
-      adapter.format = "%m" # easier to parse
+    context "when true (default)" do
+      before do
+        adapter.write(event)
+      end
+
+      it "should be written" do
+        expect(header).to match(Yell::Adapters::Datefile::HeaderRegexp)
+      end
+
+      it "should be rewritten upon rollover" do
+        Timecop.freeze(tomorrow) { adapter.write(event) }
+
+        expect(File.symlink?(filename)).to be_true
+        expect(File.readlink(filename)).to eq(tomorrow_filename)
+      end
+    end
+
+    context "when false" do
+      before do
+        adapter.header = false
+      end
+
+      it "should not be written" do
+        adapter.write(event)
+
+        expect(header).to eq("Hello World\n")
+      end
     end
+  end
 
-    it "should be written by default" do
-      adapter.write( event )
+  context "another adapter with the same :filename" do
+    let(:another_adapter) { Yell::Adapters::Datefile.new(:filename => filename) }
 
-      header.should match(Yell::Adapters::Datefile::HeaderRegexp)
+    before do
+      adapter.write(event)
     end
 
-    it "should not be written when false" do
-      adapter.header = false
-      adapter.write( event )
+    it "should not write the header again" do
+      another_adapter.write(event)
 
-      header.should == "Hello World\n"
+      # 1: header
+      # 2: adapter write
+      # 3: another_adapter: write
+      expect(File.readlines(today_filename).size).to eq(3)
     end
   end
 

data/spec/yell/adapters/file_spec.rb

@@ -4,18 +4,18 @@ describe Yell::Adapters::File do
   let(:devnull) { File.new('/dev/null', 'w') }
 
   before do
-    stub( File ).open( anything, anything ) { devnull }
+    stub(File).open(anything, anything) { devnull }
   end
 
-  it { should be_kind_of Yell::Adapters::Io }
+  it { should be_kind_of(Yell::Adapters::Io) }
 
-  context :stream do
-    subject { Yell::Adapters::File.new.send :stream }
+  context "#stream" do
+    subject { Yell::Adapters::File.new.send(:stream) }
 
-    it { should be_kind_of File }
+    it { should be_kind_of(File) }
   end
 
-  context :write do
+  context "#write" do
     let(:logger) { Yell::Logger.new }
     let(:event) { Yell::Event.new(logger, 1, "Hello World") }
 
@@ -24,20 +24,20 @@ describe Yell::Adapters::File do
       let(:adapter) { Yell::Adapters::File.new }
 
       it "should print to file" do
-        mock( File ).open( filename, File::WRONLY|File::APPEND|File::CREAT ) { devnull }
+        mock(File).open(filename, File::WRONLY|File::APPEND|File::CREAT) { devnull }
 
-        adapter.write( event )
+        adapter.write(event)
       end
     end
 
     context "with given :filename" do
       let(:filename) { fixture_path + '/filename.log' }
-      let(:adapter) { Yell::Adapters::File.new( :filename => filename ) }
+      let(:adapter) { Yell::Adapters::File.new(:filename => filename) }
 
       it "should print to file" do
-        mock( File ).open( filename, File::WRONLY|File::APPEND|File::CREAT ) { devnull }
+        mock(File).open(filename, File::WRONLY|File::APPEND|File::CREAT) { devnull }
 
-        adapter.write( event )
+        adapter.write(event)
       end
     end
 
@@ -46,27 +46,27 @@ describe Yell::Adapters::File do
       let(:adapter) { Yell::Adapters::File.new( :filename => pathname ) }
 
       it "should accept pathanme as filename" do
-        mock( File ).open( pathname.to_s, File::WRONLY|File::APPEND|File::CREAT ) { devnull }
+        mock(File).open(pathname.to_s, File::WRONLY|File::APPEND|File::CREAT) { devnull }
 
-        adapter.write( event )
+        adapter.write(event)
       end
     end
 
-    context :sync do
+    context "#sync" do
       let(:adapter) { Yell::Adapters::File.new }
 
       it "should sync by default" do
-        mock( devnull ).sync=( true )
+        mock(devnull).sync=(true)
 
-        adapter.write( event )
+        adapter.write(event)
       end
 
       it "pass the option to File" do
         adapter.sync = false
 
-        mock( devnull ).sync=( false )
+        mock(devnull).sync=(false)
 
-        adapter.write( event )
+        adapter.write(event)
       end
     end
   end