yell 1.3.0 → 1.4.0

data/spec/yell/level_spec.rb

@@ -5,127 +5,139 @@ describe Yell::Level do
   context "default" do
     let(:level) { Yell::Level.new }
 
-    it { level.at?(:debug).should be_true }
-    it { level.at?(:info).should be_true }
-    it { level.at?(:warn).should be_true }
-    it { level.at?(:error).should be_true }
-    it { level.at?(:fatal).should be_true }
+    it "should should return correctly" do
+      expect(level.at?(:debug)).to be_true
+      expect(level.at?(:info)).to be_true
+      expect(level.at?(:warn)).to be_true
+      expect(level.at?(:error)).to be_true
+      expect(level.at?(:fatal)).to be_true
+    end
   end
 
   context "given a Symbol" do
-    let(:level) { Yell::Level.new(subject) }
+    let(:level) { Yell::Level.new(severity) }
 
-    context :debug do
-      subject { :debug }
+    context ":debug" do
+      let(:severity) { :debug }
 
-      it { level.at?(:debug).should be_true }
-      it { level.at?(:info).should be_true }
-      it { level.at?(:warn).should be_true }
-      it { level.at?(:error).should be_true }
-      it { level.at?(:fatal).should be_true }
+      it "should should return correctly" do
+        expect(level.at?(:debug)).to be_true
+        expect(level.at?(:info)).to be_true
+        expect(level.at?(:warn)).to be_true
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_true
+      end
     end
 
-    context :info do
-      subject { :info }
+    context ":info" do
+      let(:severity) { :info }
 
-      it { level.at?(:debug).should be_false }
-      it { level.at?(:info).should be_true }
-      it { level.at?(:warn).should be_true }
-      it { level.at?(:error).should be_true }
-      it { level.at?(:fatal).should be_true }
+      it "should should return correctly" do
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_true
+        expect(level.at?(:warn)).to be_true
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_true
+      end
     end
 
-    context :warn do
-      subject { :warn }
+    context ":warn" do
+      let(:severity) { :warn }
 
-      it { level.at?(:debug).should be_false }
-      it { level.at?(:info).should be_false }
-      it { level.at?(:warn).should be_true }
-      it { level.at?(:error).should be_true }
-      it { level.at?(:fatal).should be_true }
+      it "should should return correctly" do
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_false
+        expect(level.at?(:warn)).to be_true
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_true
+      end
     end
 
-    context :error do
-      subject { :error }
+    context ":error" do
+      let(:severity) { :error }
 
-      it { level.at?(:debug).should be_false }
-      it { level.at?(:info).should be_false }
-      it { level.at?(:warn).should be_false }
-      it { level.at?(:error).should be_true }
-      it { level.at?(:fatal).should be_true }
+      it "should should return correctly" do
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_false
+        expect(level.at?(:warn)).to be_false
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_true
+      end
     end
 
-    context :fatal do
-      subject { :fatal }
+    context ":fatal" do
+      let(:severity) { :fatal }
 
-      it { level.at?(:debug).should be_false }
-      it { level.at?(:info).should be_false }
-      it { level.at?(:warn).should be_false }
-      it { level.at?(:error).should be_false }
-      it { level.at?(:fatal).should be_true }
+      it "should should return correctly" do
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_false
+        expect(level.at?(:warn)).to be_false
+        expect(level.at?(:error)).to be_false
+        expect(level.at?(:fatal)).to be_true
+      end
     end
   end
 
   context "given a String" do
-    let(:level) { Yell::Level.new(subject) }
+    let(:level) { Yell::Level.new(severity) }
 
     context "basic string" do
-      subject { 'error' }
-
-      it "should be valid" do
-        level.at?(:debug).should be_false
-        level.at?(:info).should be_false
-        level.at?(:warn).should be_false
-        level.at?(:error).should be_true
-        level.at?(:fatal).should be_true
+      let(:severity) { 'error' }
+
+      it "should should return correctly" do
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_false
+        expect(level.at?(:warn)).to be_false
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_true
       end
     end
 
     context "complex string with outer boundaries" do
-      subject { 'gte.info lte.error' }
-
-      it "should be valid" do
-        level.at?(:debug).should be_false
-        level.at?(:info).should be_true
-        level.at?(:warn).should be_true
-        level.at?(:error).should be_true
-        level.at?(:fatal).should be_false
+      let(:severity) { 'gte.info lte.error' }
+
+      it "should should return correctly" do
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_true
+        expect(level.at?(:warn)).to be_true
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_false
       end
     end
 
     context "complex string with inner boundaries" do
-      subject { 'gt.info lt.error' }
+      let(:severity) { 'gt.info lt.error' }
 
       it "should be valid" do
-        level.at?(:debug).should be_false
-        level.at?(:info).should be_false
-        level.at?(:warn).should be_true
-        level.at?(:error).should be_false
-        level.at?(:fatal).should be_false
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_false
+        expect(level.at?(:warn)).to be_true
+        expect(level.at?(:error)).to be_false
+        expect(level.at?(:fatal)).to be_false
       end
     end
 
     context "complex string with precise boundaries" do
-      subject { 'at.info at.error' }
+      let(:severity) { 'at.info at.error' }
 
       it "should be valid" do
-        level.at?(:debug).should be_false
-        level.at?(:info).should be_true
-        level.at?(:warn).should be_false
-        level.at?(:error).should be_true
-        level.at?(:fatal).should be_false
+        expect(level.at?(:debug)).to be_false
+        expect(level.at?(:info)).to be_true
+        expect(level.at?(:warn)).to be_false
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_false
       end
     end
 
     context "complex string with combined boundaries" do
-      subject { 'gte.error at.debug' }
+      let(:severity) { 'gte.error at.debug' }
 
       it "should be valid" do
-        level.at?(:debug).should be_true
-        level.at?(:info).should be_false
-        level.at?(:warn).should be_false
-        level.at?(:error).should be_true
-        level.at?(:fatal).should be_true
+        expect(level.at?(:debug)).to be_true
+        expect(level.at?(:info)).to be_false
+        expect(level.at?(:warn)).to be_false
+        expect(level.at?(:error)).to be_true
+        expect(level.at?(:fatal)).to be_true
       end
     end
   end
@@ -133,43 +145,56 @@ describe Yell::Level do
   context "given an Array" do
     let(:level) { Yell::Level.new( [:debug, :warn, :fatal] ) }
 
-    it { level.at?(:debug).should be_true }
-    it { level.at?(:info).should be_false }
-    it { level.at?(:warn).should be_true }
-    it { level.at?(:error).should be_false }
-    it { level.at?(:fatal).should be_true }
+    it "should return correctly" do
+      expect(level.at?(:debug)).to be_true
+      expect(level.at?(:info)).to be_false
+      expect(level.at?(:warn)).to be_true
+      expect(level.at?(:error)).to be_false
+      expect(level.at?(:fatal)).to be_true
+    end
   end
 
   context "given a Range" do
     let(:level) { Yell::Level.new( (1..3) ) }
 
-    it { level.at?(:debug).should be_false }
-    it { level.at?(:info).should be_true }
-    it { level.at?(:warn).should be_true }
-    it { level.at?(:error).should be_true }
-    it { level.at?(:fatal).should be_false }
+    it "should return correctly" do
+      expect(level.at?(:debug)).to be_false
+      expect(level.at?(:info)).to be_true
+      expect(level.at?(:warn)).to be_true
+      expect(level.at?(:error)).to be_true
+      expect(level.at?(:fatal)).to be_false
+    end
   end
 
   context "given a Yell::Level instance" do
     let(:level) { Yell::Level.new(:warn) }
 
-    it { level.at?(:debug).should be_false }
-    it { level.at?(:info).should be_false }
-    it { level.at?(:warn).should be_true }
-    it { level.at?(:error).should be_true }
-    it { level.at?(:fatal).should be_true }
+    it "should return correctly" do
+      expect(level.at?(:debug)).to be_false
+      expect(level.at?(:info)).to be_false
+      expect(level.at?(:warn)).to be_true
+      expect(level.at?(:error)).to be_true
+      expect(level.at?(:fatal)).to be_true
+    end
   end
 
   context "backwards compatibility" do
     let(:level) { Yell::Level.new :warn }
 
-    it { level.to_i.should == 2 }
-    it { Integer(level).should == 2 }
+    it "should return correctly to :to_i" do
+      expect(level.to_i).to eq(2)
+    end
+
+    it "should typecast with Integer correctly" do
+      expect(Integer(level)).to eq(2)
+    end
 
     it "should be compatible when passing to array (https://github.com/rudionrails/yell/issues/1)" do
       severities = %w(FINE INFO WARNING SEVERE SEVERE INFO)
 
-      severities[level].should == "WARNING"
+      expect(severities[level]).to eq("WARNING")
     end
   end
+
 end
+

data/spec/yell/loggable_spec.rb

@@ -5,14 +5,15 @@ class LoggableFactory
 end
 
 describe Yell::Loggable do
-  subject { LoggableFactory.new }
+  let(:factory) { LoggableFactory.new }
+  subject { factory }
 
-  it { should respond_to :logger }
+  it { should respond_to(:logger) }
 
-  it ":logger should pass class name to the repository" do
-    mock( Yell::Repository )[ LoggableFactory ]
+  it "should make a lookup in the Yell::Repository" do
+    mock(Yell::Repository)[LoggableFactory]
 
-    subject.logger
+    factory.logger
   end
 
 end

data/spec/yell/logger_spec.rb

@@ -15,112 +15,129 @@ end
 describe Yell::Logger do
   let(:filename) { fixture_path + '/logger.log' }
 
-  context "a Logger instance" do
+  describe "a Logger instance" do
     let(:logger) { Yell::Logger.new }
+    subject { logger }
 
     its(:name) { should be_nil }
 
     context "log methods" do
-      subject { logger }
+      it { should respond_to(:debug) }
+      it { should respond_to(:debug?) }
 
-      it { should respond_to :debug }
-      it { should respond_to :debug? }
+      it { should respond_to(:info) }
+      it { should respond_to(:info?) }
 
-      it { should respond_to :info }
-      it { should respond_to :info? }
+      it { should respond_to(:warn) }
+      it { should respond_to(:warn?) }
 
-      it { should respond_to :warn }
-      it { should respond_to :warn? }
+      it { should respond_to(:error) }
+      it { should respond_to(:error?) }
 
-      it { should respond_to :error }
-      it { should respond_to :error? }
+      it { should respond_to(:fatal) }
+      it { should respond_to(:fatal?) }
 
-      it { should respond_to :fatal }
-      it { should respond_to :fatal? }
-
-      it { should respond_to :unknown }
-      it { should respond_to :unknown? }
+      it { should respond_to(:unknown) }
+      it { should respond_to(:unknown?) }
     end
 
-    context "default adapter" do
-      let(:adapters) { logger.instance_variable_get(:@adapters) }
+    context "default #adapters" do
+      subject { logger.adapters }
 
-      it { adapters.size.should == 1 }
-      it { adapters.first.should be_kind_of(Yell::Adapters::File) }
+      its(:size) { should eq(1) }
+      its(:first) { should be_kind_of(Yell::Adapters::File) }
     end
 
-    context "default :level" do
+    context "default #level" do
       subject { logger.level }
 
       it { should be_instance_of(Yell::Level) }
-      its(:severities) { should == [true, true, true, true, true, true] }
+      its(:severities) { should eq([true, true, true, true, true, true]) }
     end
 
-    context "default :trace" do
+    context "default #trace" do
       subject { logger.trace }
 
       it { should be_instance_of(Yell::Level) }
-      its(:severities) { should == [false, false, false, true, true, true] } # from error onwards
+      its(:severities) { should eq([false, false, false, true, true, true]) } # from error onwards
     end
   end
 
-  context "initialize with a :name" do
+  describe "initialize with #name" do
     let(:name) { 'test' }
     let!(:logger) { Yell.new(:name => name) }
 
-    it "should set the logger's name" do
-      logger.name.should == name
-    end
-
     it "should be added to the repository" do
-      Yell::Repository[name].should == logger
+      expect(Yell::Repository[name]).to eq(logger)
     end
   end
 
-  context "initialize with :trace" do
+  context "initialize with #level" do
+    let(:level) { :error }
+    let(:logger) { Yell.new(:level => level) }
+    subject { logger.level }
+
+    it { should be_instance_of(Yell::Level) }
+    its(:severities) { should eq([false, false, false, true, true, true]) }
+  end
+
+  context "initialize with #trace" do
+    let(:trace) { :info }
+    let(:logger) { Yell.new(:trace => trace) }
+    subject { logger.trace }
+
+    it { should be_instance_of(Yell::Level) }
+    its(:severities) { should eq([false, true, true, true, true, true]) }
+  end
+
+  context "initialize with #silence" do
+    let(:silence) { "test" }
+    let(:logger) { Yell.new(:silence => silence) }
+    subject { logger.silencer }
+
+    it { should be_instance_of(Yell::Silencer) }
+    its(:patterns) { should eq([silence]) }
   end
 
-  context "initialize with a :filename" do
+  context "initialize with a #filename" do
     it "should call adapter with :file" do
-      mock.proxy( Yell::Adapters::File ).new( :filename => 'test.log' )
+      mock.proxy(Yell::Adapters::File).new(:filename => filename)
 
-      Yell::Logger.new 'test.log'
+      Yell::Logger.new(filename)
     end
   end
 
-  context "initialize with a :filename of Pathname type" do
+  context "initialize with a #filename of Pathname type" do
+    let(:pathname) { Pathname.new(filename) }
+
     it "should call adapter with :file" do
-      mock.proxy( Yell::Adapters::File ).new( :filename => Pathname.new('test.log') )
+      mock.proxy(Yell::Adapters::File).new(:filename => pathname)
 
-      Yell::Logger.new Pathname.new('test.log')
+      Yell::Logger.new(pathname)
     end
   end
 
   context "initialize with a :stdout adapter" do
-    before do
-      mock.proxy( Yell::Adapters::Stdout ).new( anything )
-    end
+    before { mock.proxy(Yell::Adapters::Stdout).new(anything) }
 
     it "should call adapter with STDOUT" do
-      Yell::Logger.new STDOUT
+      Yell::Logger.new(STDOUT)
     end
 
     it "should call adapter with :stdout" do
-      Yell::Logger.new :stdout
+      Yell::Logger.new(:stdout)
     end
   end
 
   context "initialize with a :stderr adapter" do
-    before do
-      mock.proxy( Yell::Adapters::Stderr ).new( anything )
-    end
+    before { mock.proxy(Yell::Adapters::Stderr).new(anything) }
 
     it "should call adapter with STDERR" do
-      Yell::Logger.new STDERR
+      Yell::Logger.new(STDERR)
     end
 
     it "should call adapter with :stderr" do
-      Yell::Logger.new :stderr
+      Yell::Logger.new(:stderr)
     end
   end
 
@@ -134,8 +151,8 @@ describe Yell::Logger do
         Yell::Logger.new(:level => level) { |l| l.adapter(:stdout) }
       end
 
-      its(:level) { should == level }
-      its('adapters.size') { should == 1 }
+      its(:level) { should eq(level) }
+      its('adapters.size') { should eq(1) }
       its('adapters.first') { should be_instance_of(Yell::Adapters::Stdout) }
     end
 
@@ -144,32 +161,32 @@ describe Yell::Logger do
         Yell::Logger.new(:level => level) { adapter(:stdout) }
       end
 
-      its(:level) { should == level }
-      its('adapters.size') { should == 1 }
+      its(:level) { should eq(level) }
+      its('adapters.size') { should eq(1) }
       its('adapters.first') { should be_instance_of(Yell::Adapters::Stdout) }
     end
   end
 
-  context "initialize with :adapters option" do
+  context "initialize with #adapters option" do
     let(:logger) do
-      Yell::Logger.new :adapters => [ :stdout, { :stderr => {:level => :error} } ]
+      Yell::Logger.new(:adapters => [:stdout, {:stderr => {:level => :error}}])
     end
 
-    let(:adapters) { logger.instance_variable_get :@adapters }
+    let(:adapters) { logger.instance_variable_get(:@adapters) }
     let(:stdout) { adapters.first }
     let(:stderr) { adapters.last }
 
     it "should define those adapters" do
-      adapters.size.should == 2
+      expect(adapters.size).to eq(2)
 
-      stdout.should be_kind_of Yell::Adapters::Stdout
-      stderr.should be_kind_of Yell::Adapters::Stderr
+      expect(stdout).to be_kind_of(Yell::Adapters::Stdout)
+      expect(stderr).to be_kind_of(Yell::Adapters::Stderr)
     end
 
     it "should pass :level to :stderr adapter" do
-      stderr.level.at?(:warn).should be_false
-      stderr.level.at?(:error).should be_true
-      stderr.level.at?(:fatal).should be_true
+      expect(stderr.level.at?(:warn)).to be_false
+      expect(stderr.level.at?(:error)).to be_true
+      expect(stderr.level.at?(:fatal)).to be_true
     end
   end
 
@@ -181,8 +198,8 @@ describe Yell::Logger do
       factory = LoggerFactory.new
       factory.logger = logger
 
-      mock( stdout.send(:stream) ).syswrite( "#{__FILE__}, 7: foo\n" )
-      mock( stdout.send(:stream) ).syswrite( "#{__FILE__}, 11: bar\n" )
+      mock(stdout.send(:stream)).syswrite("#{__FILE__}, 7: foo\n")
+      mock(stdout.send(:stream)).syswrite("#{__FILE__}, 11: bar\n")
 
       factory.foo
       factory.bar
@@ -195,27 +212,50 @@ describe Yell::Logger do
 
     it "should output a single message" do
       logger.info "Hello World"
-      line.should ==  "Hello World\n"
+
+      expect(line).to eq("Hello World\n")
     end
 
     it "should output multiple messages" do
       logger.info "Hello", "W", "o", "r", "l", "d"
-      line.should == "Hello W o r l d\n"
+
+      expect(line).to eq("Hello W o r l d\n")
     end
 
     it "should output a hash and message" do
       logger.info "Hello World", :test => :message
-      line.should == "Hello World test: message\n"
+
+      expect(line).to eq("Hello World test: message\n")
     end
 
     it "should output a hash and message" do
       logger.info( {:test => :message}, "Hello World" )
-      line.should == "test: message Hello World\n"
+
+      expect(line).to eq("test: message Hello World\n")
     end
 
     it "should output a hash and block" do
       logger.info(:test => :message) { "Hello World" }
-      line.should == "test: message Hello World\n"
+
+      expect(line).to eq("test: message Hello World\n")
+    end
+  end
+
+  context "logging with a silencer" do
+    let(:silence) { "this" }
+    let(:stdout) { Yell::Adapters::Stdout.new }
+    let(:logger) { Yell::Logger.new(stdout, :silence => silence) }
+
+    it "should not pass a matching message to any adapter" do
+      dont_allow(stdout).write
+
+      logger.info "this should not be logged"
+    end
+
+    it "should pass a non-matching message to any adapter" do
+      mock(stdout).write(is_a(Yell::Event))
+
+      logger.info "that should be logged"
     end
   end