yell 1.3.0 → 1.4.0

data/spec/yell/adapters/io_spec.rb

@@ -8,59 +8,63 @@ describe Yell::Adapters::Io do
     it "should set default :format" do
       adapter = Yell::Adapters::Io.new
 
-      adapter.format.should be_kind_of(Yell::Formatter)
+      expect(adapter.format).to be_kind_of(Yell::Formatter)
     end
 
-    context :level do
+    context ":level" do
       let(:level) { Yell::Level.new(:warn) }
 
       it "should set the level" do
         adapter = Yell::Adapters::Io.new(:level => level)
-        adapter.level.should == level
+
+        expect(adapter.level).to eq(level)
       end
 
       it "should set the level when block was given" do
         adapter = Yell::Adapters::Io.new { |a| a.level = level }
-        adapter.level.should == level
+
+        expect(adapter.level).to eq(level)
       end
     end
 
-    context :format do
+    context ":format" do
       let(:format) { Yell::Formatter.new }
 
       it "should set the level" do
         adapter = Yell::Adapters::Io.new(:format => format)
-        adapter.format.should == format
+
+        expect(adapter.format).to eq(format)
       end
 
       it "should set the level when block was given" do
         adapter = Yell::Adapters::Io.new { |a| a.format = format }
-        adapter.format.should == format
+
+        expect(adapter.format).to eq(format)
       end
     end
   end
 
-  context :write do
+  context "#write" do
     let(:logger) { Yell::Logger.new }
     let(:event) { Yell::Event.new(logger, 1, "Hello World") }
     let(:adapter) { Yell::Adapters::Io.new }
     let(:stream) { File.new('/dev/null', 'w') }
 
     before do
-      stub( adapter ).stream { stream }
+      stub(adapter).stream { stream }
     end
 
     it "should format the message" do
-      mock.proxy( adapter.format ).format( event )
+      mock.proxy(adapter.format).format( event )
 
-      adapter.write( event )
+      adapter.write(event)
     end
 
     it "should print formatted message to stream" do
       formatted = Yell::Formatter.new.format( event )
-      mock( stream ).syswrite( formatted << "\n" )
+      mock(stream).syswrite( formatted << "\n" )
 
-      adapter.write( event )
+      adapter.write(event)
     end
   end
 

data/spec/yell/adapters/streams_spec.rb

@@ -2,24 +2,24 @@ require 'spec_helper'
 
 describe Yell::Adapters::Stdout do
 
-  it { should be_kind_of Yell::Adapters::Io }
+  it { should be_kind_of(Yell::Adapters::Io) }
 
-  context :stream do
+  context "#stream" do
     subject { Yell::Adapters::Stdout.new.send :stream }
 
-    it { should be_kind_of IO }
+    it { should be_kind_of(IO) }
   end
 
 end
 
 describe Yell::Adapters::Stderr do
 
-  it { should be_kind_of Yell::Adapters::Io }
+  it { should be_kind_of(Yell::Adapters::Io) }
 
-  context :stream do
-    subject { Yell::Adapters::Stderr.new.send :stream }
+  context "#stream" do
+    subject { Yell::Adapters::Stderr.new.send(:stream) }
 
-    it { should be_kind_of IO }
+    it { should be_kind_of(IO) }
   end
 
 end

data/spec/yell/adapters_spec.rb

@@ -2,46 +2,41 @@ require 'spec_helper'
 
 describe Yell::Adapters do
 
-  context :new do
-    context "given a Yell::Adapters::Base ancestor" do
-      let(:stdout) { Yell::Adapters::Stdout.new }
+  context ".new" do
+    it "should accept an adapter instance" do
+      stdout = Yell::Adapters::Stdout.new
+      adapter = Yell::Adapters.new(stdout)
 
-      it "should return the instance" do
-        Yell::Adapters.new( stdout ).should == stdout
-      end
+      expect(adapter).to eq(stdout)
     end
 
-    context "given STDOUT" do
-      it "should initialize Stdout adapter" do
-        mock.proxy( Yell::Adapters::Stdout ).new( anything )
+    it "should accept STDOUT" do
+      mock.proxy(Yell::Adapters::Stdout).new(anything)
 
-        Yell::Adapters.new STDOUT
-      end
+      Yell::Adapters.new(STDOUT)
     end
 
-    context "given STDERR" do
-      it "should initialize Stderr adapter" do
-        mock.proxy( Yell::Adapters::Stderr ).new( anything )
+    it "should accept STDERR" do
+      mock.proxy(Yell::Adapters::Stderr).new(anything)
 
-        Yell::Adapters.new STDERR
-      end
+      Yell::Adapters.new(STDERR)
     end
 
-    context "given an unregistered adapter" do
-      it "should raise AdapterNotFound" do
-        lambda { Yell::Adapters.new :unknown }.should raise_error Yell::AdapterNotFound
-      end
+    it "should raise an unregistered adapter" do
+      expect {
+        Yell::Adapters.new :unknown
+      }.to raise_error(Yell::AdapterNotFound)
     end
   end
 
-  context :register do
+  context ".register" do
     let(:name) { :test }
     let(:klass) { mock }
 
-    before { Yell::Adapters.register( name, klass ) }
+    before { Yell::Adapters.register(name, klass) }
 
     it "should allow to being called from :new" do
-      mock( klass ).new( anything )
+      mock(klass).new(anything)
 
       Yell::Adapters.new(name)
     end

data/spec/yell/configuration_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Yell::Configuration do
 
-  describe ":load!" do
+  describe ".load!" do
     let(:file) { fixture_path + '/yell.yml' }
     let(:config) { Yell::Configuration.load!(file) }
 
@@ -12,23 +12,23 @@ describe Yell::Configuration do
     it { should have_key(:level) }
     it { should have_key(:adapters) }
 
-    context :level do
+    context ":level" do
       subject { config[:level] }
 
-      it { should == "info" }
+      it { should eq("info") }
     end
 
-    context :adapters do
+    context ":adapters" do
       subject { config[:adapters] }
 
       it { should be_kind_of(Array) }
 
       # stdout
-      it { subject.first.should == :stdout }
+      it { expect(subject.first).to eq(:stdout) }
 
       # stderr
-      it { subject.last.should be_kind_of(Hash) }
-      it { subject.last.should == { :stderr => {:level => 'gte.error'} } }
+      it { expect(subject.last).to be_kind_of(Hash) }
+      it { expect(subject.last).to eq(:stderr => {:level => 'gte.error'}) }
     end
   end
 

data/spec/yell/event_spec.rb

@@ -20,39 +20,36 @@ describe Yell::Event do
   let(:logger) { Yell::Logger.new(:trace => true) }
   let(:event) { Yell::Event.new(logger, 1, 'Hello World!') }
 
-  context :level do
+  context "#level" do
     subject { event.level }
-    it { should == 1 }
+    it { should eq(1) }
   end
 
-  context :messages do
+  context "#messages" do
     subject { event.messages }
-    it { should == ['Hello World!'] }
+    it { should eq(['Hello World!']) }
   end
 
-  context :time do
-    subject { event.time.to_s }
-
+  context "#time" do
     let(:time) { Time.now }
+    subject { event.time.to_s }
 
-    before do
-      Timecop.freeze( time )
-    end
+    before { Timecop.freeze(time) }
 
-    it { should == time.to_s }
+    it { should eq(time.to_s) }
   end
 
-  context :hostname do
+  context "#hostname" do
     subject { event.hostname }
-    it { should == Socket.gethostname }
+    it { should eq(Socket.gethostname) }
   end
 
-  context :pid do
+  context "#pid" do
     subject { event.pid }
-    it { should == Process.pid }
+    it { should eq(Process.pid) }
   end
 
-  context "pid when forked", :pending => RUBY_PLATFORM == 'java' do # no forking with jruby
+  context "#id when forked", :pending => RUBY_PLATFORM == 'java' ? "No forking with jruby" : false do
     subject { @pid }
 
     before do
@@ -69,31 +66,32 @@ describe Yell::Event do
       read.close
     end
 
-    it { should_not == Process.pid }
-    it { should == @child_pid }
+    it { should_not eq(Process.pid) }
+    it { should eq(@child_pid) }
   end
 
-  context :progname do
+  context "#progname" do
     subject { event.progname }
-    it { should == $0 }
+    it { should eq($0) }
   end
 
-  context :caller do
+  context ":caller" do
     subject { EventFactory.event(logger, 1, "Hello World") }
 
     context "with trace" do
-      its(:file) { should == __FILE__ }
-      its(:line) { should == "8" }
-      its(:method) { should == "event" }
+      its(:file) { should eq(__FILE__) }
+      its(:line) { should eq("8") }
+      its(:method) { should eq("event") }
     end
 
     context "without trace" do
       before { logger.trace = false }
 
-      its(:file) { should == "" }
-      its(:line) { should == "" }
-      its(:method) { should == "" }
+      its(:file) { should eq("") }
+      its(:line) { should eq("") }
+      its(:method) { should eq("") }
     end
   end
 
 end
+

data/spec/yell/formatter_spec.rb

@@ -3,127 +3,134 @@ require 'spec_helper'
 describe Yell::Formatter do
 
   let(:logger) { Yell::Logger.new }
-  let(:formatter) { Yell::Formatter.new(subject) }
   let(:event) { Yell::Event.new(logger, 1, 'Hello World!') }
   let(:time) { Time.now }
 
-  let(:format) { formatter.format(event) }
+  let(:pattern) { "%m" }
+  let(:formatter) { Yell::Formatter.new(pattern) }
 
   before do
-    Timecop.freeze( time )
+    Timecop.freeze(time)
   end
 
-  context "%m" do
-    subject { "%m" }
-    it { format.should == event.messages.join(' ') }
-  end
+  describe "#format" do
+    subject { formatter.format(event) }
 
-  context "%l" do
-    subject { "%l" }
-    it { format.should == Yell::Severities[event.level][0,1] }
-  end
+    context "%m" do
+      let(:pattern) { "%m" }
+      it { should eq(event.messages.join(' ')) }
+    end
 
-  context "%L" do
-    subject { "%L" }
-    it { format.should == Yell::Severities[event.level] }
-  end
+    context "%l" do
+      let(:pattern) { "%l" }
+      it { should eq(Yell::Severities[event.level][0,1]) }
+    end
 
-  context "%d" do
-    subject { "%d" }
-    it { format.should == event.time.iso8601 }
-  end
+    context "%L" do
+      let(:pattern) { "%L" }
+      it { should eq(Yell::Severities[event.level]) }
+    end
 
-  context "%p" do
-    subject { "%p" }
-    it { format.should == event.pid.to_s }
-  end
+    context "%d" do
+      let(:pattern) { "%d" }
+      it { should eq(event.time.iso8601) }
+    end
 
-  context "%P" do
-    subject { "%P" }
-    it { format.should == event.progname }
-  end
-  context "%t" do
-    subject { "%t" }
-    it { format.should == event.thread_id.to_s }
-  end
+    context "%p" do
+      let(:pattern) { "%p" }
+      it { should eq(event.pid.to_s) }
+    end
 
-  context "%h" do
-    subject { "%h" }
-    it { format.should == event.hostname }
-  end
+    context "%P" do
+      let(:pattern) { "%P" }
+      it { should eq(event.progname) }
+    end
+    context "%t" do
+      let(:pattern) { "%t" }
+      it { should eq(event.thread_id.to_s) }
+    end
 
-  context "caller" do
-    let(:_caller) { [nil, nil, "/path/to/file.rb:123:in `test_method'"] }
+    context "%h" do
+      let(:pattern) { "%h" }
+      it { should eq(event.hostname) }
+    end
 
-    before do
-      any_instance_of( Yell::Event ) do |e|
-        stub(e).file { "/path/to/file.rb" }
-        stub(e).line { "123" }
-        stub(e).method { "test_method" }
+    context ":caller" do
+      let(:_caller) { [nil, nil, "/path/to/file.rb:123:in `test_method'"] }
+
+      before do
+        any_instance_of(Yell::Event) do |e|
+          stub(e).file { "/path/to/file.rb" }
+          stub(e).line { "123" }
+          stub(e).method { "test_method" }
+        end
       end
-    end
 
-    context "%F" do
-      subject { "%F" }
-      it { format.should == "/path/to/file.rb" }
-    end
+      context "%F" do
+        let(:pattern) { "%F" }
+        it { should eq("/path/to/file.rb") }
+      end
 
-    context "%f" do
-      subject { "%f" }
-      it { format.should == "file.rb" }
-    end
+      context "%f" do
+        let(:pattern) { "%f" }
+        it { should eq("file.rb") }
+      end
 
-    context "%M" do
-      subject { "%M" }
-      it { format.should == "test_method" }
-    end
+      context "%M" do
+        let(:pattern) { "%M" }
+        it { should eq("test_method") }
+      end
 
-    context "%n" do
-      subject { "%n" }
-      it { format.should == "123" }
+      context "%n" do
+        let(:pattern) { "%n" }
+        it { should eq("123") }
+      end
     end
   end
 
-  context "NoFormat" do
-    subject { Yell::NoFormat }
-    it { format.should == "Hello World!"  }
-  end
+  describe "#format from presets" do
+    subject { formatter.format(event) }
 
-  context "DefaultFormat" do
-    subject { Yell::DefaultFormat }
-    it { format.should == "#{time.iso8601} [ INFO] #{$$} : Hello World!"  }
-  end
+    context "NoFormat" do
+      let(:pattern) { Yell::NoFormat }
+      it { should eq("Hello World!") }
+    end
 
-  context "BasicFormat" do
-    subject { Yell::BasicFormat }
-    it { format.should == "I, #{time.iso8601} : Hello World!"  }
-  end
+    context "DefaultFormat" do
+      let(:pattern) { Yell::DefaultFormat }
+      it { should eq("#{time.iso8601} [ INFO] #{$$} : Hello World!")  }
+    end
+
+    context "BasicFormat" do
+      let(:pattern) { Yell::BasicFormat }
+      it { should eq("I, #{time.iso8601} : Hello World!") }
+    end
 
-  context "ExtendedFormat" do
-    subject { Yell::ExtendedFormat }
-    it { format.should == "#{time.iso8601} [ INFO] #{$$} #{Socket.gethostname} : Hello World!" }
+    context "ExtendedFormat" do
+      let(:pattern) { Yell::ExtendedFormat }
+      it { should eq("#{time.iso8601} [ INFO] #{$$} #{Socket.gethostname} : Hello World!") }
+    end
   end
 
-  context "Exceptions" do
+  describe "#format from exception" do
     let(:exception) { StandardError.new( "This is an Exception" ) }
     let(:event) { Yell::Event.new(logger, 1, exception) }
-
-    subject { "%m" }
+    subject { formatter.format(event) }
 
     before do
-      mock( exception ).backtrace.times(any_times) { ["backtrace"] }
+      mock(exception).backtrace.times(any_times) { ["backtrace"] }
     end
 
-    it { format.should == "StandardError: This is an Exception\n\tbacktrace" }
+    it { should eq("StandardError: This is an Exception\n\tbacktrace") }
   end
 
-  context "Hashes" do
+  describe "#format from hash messages" do
     let(:hash) { { :test => 'message' } }
     let(:event) { Yell::Event.new(logger, 1, hash) }
+    subject { formatter.format(event) }
 
-    subject { "%m" }
-
-    it { format.should == "test: message" }
+    it { should eq("test: message") }
   end
 
 end
+