yell 1.2.3 → 1.3.0

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012 Rudolf Schmidt
+Copyright (c) 2011-2013 Rudolf Schmidt
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/yell.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-# Copyright (c) 2011-2012 Rudolf Schmidt
+# Copyright (c) 2011-2013 Rudolf Schmidt
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -71,7 +71,8 @@ module Yell #:nodoc:
       Yell.new Yell::Configuration.load!(file)
     end
 
-    def env #:nodoc:
+    # @private
+    def env
       return ENV['YELL_ENV']  if ENV.key? 'YELL_ENV'
       return ENV['RACK_ENV']  if ENV.key? 'RACK_ENV'
       return ENV['RAILS_ENV'] if ENV.key? 'RAILS_ENV'
@@ -83,7 +84,8 @@ module Yell #:nodoc:
       end
     end
 
-    def _deprecate( version, message, options = {} ) #:nodoc:
+    # @private
+    def _deprecate( version, message, options = {} )
       messages = ["Deprecation Warning (since v#{version}): #{message}" ]
       messages << "  before: #{options[:before]}" if options[:before]
       messages << "  after:  #{options[:after]}" if options[:after]
@@ -91,9 +93,10 @@ module Yell #:nodoc:
       _warn( *messages )
     end
 
-    def _warn( *messages ) #:nodoc:
+    # @private
+    def _warn( *messages )
       $stderr.puts "[Yell] " + messages.join( "\n" )
-    rescue
+    rescue Exception
       # do nothing
     end
   end

data/lib/yell/adapters/base.rb

@@ -138,7 +138,9 @@ module Yell #:nodoc:
         super() # init the monitor superclass
 
         setup!(options)
-        block.call(self) if block
+
+        # eval the given block
+        block.arity > 0 ? block.call(self) : instance_eval(&block) if block_given?
       end
 
       # The main method for calling the adapter.
@@ -163,12 +165,6 @@ module Yell #:nodoc:
       end
 
       # Get a pretty string representation of the adapter, including
-      # the inspectable attributes.
-      #
-      # @example Inspect the formatter.
-      #   adapter.inspect
-      #
-      # @return [String] The inspection string.
       def inspect
         inspection = inspectables.inject( [] ) { |r, c| r << "#{c}: #{send(c).inspect}" }
         "#<#{self.class.name} #{inspection * ', '}>"
@@ -221,8 +217,6 @@ module Yell #:nodoc:
       end
 
       # Get an array of inspected attributes for the adapter.
-      #
-      # @return [ String ] An array of pretty printed field values.
       def inspectables
         [ :level ]
       end

data/lib/yell/event.rb

@@ -5,7 +5,6 @@ require 'socket'
 
 module Yell #:nodoc:
 
-  #
   # Yell::Event.new( :info, 'Hello World', { :scope => 'Application' } )
   # #=> Hello World scope: Application
   class Event
@@ -19,9 +18,6 @@ module Yell #:nodoc:
     @@hostname  = Socket.gethostname rescue nil
     @@progname  = $0
 
-    # Accessor to the pid
-    attr_reader :pid
-
     # Accessor to the log level
     attr_reader :level
 
@@ -31,24 +27,20 @@ module Yell #:nodoc:
     # Accessor to the time the log event occured
     attr_reader :time
 
-    # Accessor to the current tread_id
-    attr_reader :thread_id
-
 
-    def initialize( level, *messages, &block )
-      @pid      = Process.pid
+    def initialize(logger, level, *messages, &block)
       @time     = Time.now
       @level    = level
 
       @messages = messages
       @messages << block.call if block
 
-      @thread_id  = Thread.current.object_id
-
-      @caller = caller[CallerIndex].to_s
+      @caller = logger.trace.at?(level) ? caller[CallerIndex].to_s : ''
       @file   = nil
       @line   = nil
       @method = nil
+
+      @pid = nil
     end
 
     # Accessor to the hostname
@@ -61,29 +53,36 @@ module Yell #:nodoc:
       @@progname
     end
 
+    # Accessor to the PID
+    def pid
+      Process.pid
+    end
+
+    # Accessor to the thread's id
+    def thread_id
+      Thread.current.object_id
+    end
+
     # Accessor to filename the log event occured
     def file
-      _caller! if @file.nil?
-      @file
+      @file || (_caller!; @file)
     end
 
     # Accessor to the line the log event occured
     def line
-      _caller! if @line.nil?
-      @line
+      @line || (_caller!; @line)
     end
 
     # Accessor to the method the log event occured
     def method
-      _caller! if @method.nil?
-      @method
+      @method || (_caller!; @method)
     end
 
 
     private
 
     def _caller!
-      if m = CallerRegexp.match( @caller )
+      if m = CallerRegexp.match(@caller)
         @file, @line, @method = m[1..-1]
       else
         @file, @line, @method = ['', '', '']

data/lib/yell/formatter.rb

@@ -87,24 +87,33 @@ module Yell #:nodoc:
       @pattern      = pattern || Yell::DefaultFormat
       @date_pattern = date_pattern || :iso8601
 
-      define!
+      define_date_method!
+      define_format_method!
     end
 
-    # Get a pretty string representation of the formatter, including
-    # the pattern and date pattern.
-    #
-    # @example Inspect the formatter.
-    #   formatter.inspect
-    #
-    # @return [String] The inspection string.
+    # Get a pretty string representation of the formatter, including the pattern and date pattern.
     def inspect
       "#<#{self.class.name} pattern: #{@pattern.inspect}, date_pattern: #{@date_pattern.inspect}>"
     end
 
+
     private
 
-    # defines the format method
-    def define!
+    def define_date_method!
+      buf = case @date_pattern
+      when String then "t.strftime(@date_pattern)"
+      when Symbol then respond_to?(@date_pattern, true) ? "#{@date_pattern}(t)" : "t.#{@date_pattern}"
+      else "iso8601(t)"
+      end
+
+      instance_eval %-
+        def date( t )
+          #{buf}
+        end
+      -
+    end
+
+    def define_format_method!
       buff, args, _pattern = "", [], @pattern.dup
 
       while true
@@ -126,15 +135,22 @@ module Yell #:nodoc:
       -
     end
 
-    def level( l )
-      Yell::Severities[ l ]
+    # The iso8601 implementation of the standard Time library is more than
+    # twice as slow than using strftime. So, we just implement it ourselves.
+    def iso8601( t )
+      zone = if t.utc?
+        "-00:00"
+      else
+        offset = t.utc_offset
+        sign = offset < 0 ? '-' : '+'
+        sprintf('%s%02d:%02d', sign, *(offset.abs/60).divmod(60))
+      end
+
+      t.strftime("%Y-%m-%dT%H:%M:%S#{zone}")
     end
 
-    def date( t )
-      case @date_pattern
-      when String then t.strftime( @date_pattern )
-      else t.iso8601
-      end
+    def level( l )
+      Yell::Severities[ l ]
     end
 
     def message( *messages )

data/lib/yell/level.rb

@@ -138,13 +138,7 @@ module Yell #:nodoc:
     end
     alias :to_int :to_i
 
-    # Get a pretty string representation of the level, including the
-    # severities.
-    #
-    # @example Inspect the level.
-    #   level.inspect
-    #
-    # @return [String] The inspection string.
+    # Get a pretty string representation of the level, including the severities.
     def inspect
       severities = Yell::Severities.each.with_index.inject( [] ) do |r, (l, i)|
         r << l if @severities[i]

data/lib/yell/logger.rb

@@ -14,6 +14,9 @@ module Yell #:nodoc:
     # The name of the logger instance
     attr_reader :name
 
+    # Stacktrace or not
+    attr_reader :trace
+
     # Initialize a new Logger
     #
     # @example A standard file logger
@@ -36,34 +39,67 @@ module Yell #:nodoc:
     #   Yell::Logger.new :datefile, 'development.log' do |l|
     #     l.level = :info
     #   end
-    def initialize( *args )
+    def initialize( *args, &block )
       @adapters = []
 
       # extract options
       @options = args.last.is_a?(Hash) ? args.pop : {}
 
       # adapters may be passed in the options
-      _extract_adapters!( @options )
+      extract!(@options)
 
       # check if filename was given as argument and put it into the @options
       if [String, Pathname].include?(args.last.class)
         @options[:filename] = args.pop unless @options[:filename]
       end
 
-      # set the log level when given
-      self.level = @options[:level]
-
-      # set the loggeer's name
-      self.name = @options[:name] if @options[:name]
+      self.level = @options.fetch(:level, 0) # debug by defauly
+      self.name = @options.fetch(:name, nil) # no name by default
+      self.trace = @options.fetch(:trace, :error) # trace from :error level onwards
 
       # extract adapter
-      self.adapter args.pop if args.any?
+      self.adapter(args.pop) if args.any?
 
       # eval the given block
-      yield(self) if block_given?
+      block.arity > 0 ? block.call(self) : instance_eval(&block) if block_given?
 
       # default adapter when none defined
-      self.adapter :file if @adapters.empty?
+      self.adapter(:file) if @adapters.empty?
+    end
+
+
+    # Set the name of a logger. When providing a name, the logger will
+    # automatically be added to the Yell::Repository.
+    #
+    # @return [String] The logger's name
+    def name=( val )
+      @name = val
+      Yell::Repository[@name] = self if @name
+
+      @name
+    end
+
+    # Set whether the logger should allow tracing or not. The trace option
+    # will tell the logger when to provider caller information.
+    #
+    # @example No tracing at all
+    #   trace = false
+    #
+    # @example Trace every time
+    #   race = true
+    #
+    # @example Trace from the error level onwards
+    #   trace = :error
+    #   trace = 'gte.error'
+    #
+    # @return [Yell::Level] a level representation of the tracer
+    def trace=( severity )
+      @trace = case severity
+        when true then Yell::Level.new
+        when false then Yell::Level.new( "gt.#{Yell::Severities.last}" )
+        when Yell::Level then severity
+        else Yell::Level.new( severity )
+      end
     end
 
     # Define an adapter to be used for logging.
@@ -84,9 +120,7 @@ module Yell #:nodoc:
     #   adapter( Yell::Adapter::File.new )
     #
     # @param [Symbol] type The type of the adapter, may be `:file` or `:datefile` (default `:file`)
-    #
     # @return [Yell::Adapter] The instance
-    #
     # @raise [Yell::NoSuchAdapter] Will be thrown when the adapter is not defined
     def adapter( type = :file, *args, &block )
       options = [@options, *args].inject( Hash.new ) do |h, c|
@@ -96,15 +130,6 @@ module Yell #:nodoc:
       @adapters << Yell::Adapters.new( type, options, &block )
     end
 
-    def name=( val )
-      Yell::Repository[val] = self
-    end
-
-    # Convenience method for resetting all adapters of the Logger.
-    def close
-      @adapters.each(&:close)
-    end
-
     # Creates instance methods for every log level:
     #   `debug` and `debug?`
     #   `info` and `info?`
@@ -115,31 +140,36 @@ module Yell #:nodoc:
       name = s.downcase
 
       class_eval <<-EOS, __FILE__, __LINE__
-        def #{name}?; @level.at?(#{index}); end   # def info?; @level.at?(1); end
-                                                  #
-        def #{name}( *m, &b )                     # def info( *m, &b )
-          return false unless #{name}?            #   return false unless info?
-          write Yell::Event.new(#{index}, *m, &b) #   write Yell::Event.new(1, *m, &b)
-                                                  #
-          true                                    #   true
-        end                                       # end
+        def #{name}?; @level.at?(#{index}); end         # def info?; @level.at?(1); end
+                                                        #
+        def #{name}( *m, &b )                           # def info( *m, &b )
+          return false unless #{name}?                  #   return false unless info?
+          write Yell::Event.new(self, #{index}, *m, &b) #   write Yell::Event.new(self, 1, *m, &b)
+                                                        #
+          true                                          #   true
+        end                                             # end
       EOS
     end
 
     # Get a pretty string representation of the logger.
-    #
-    # @example Inspect the logger
-    #   logger.inspect
-    #
-    # @return [String] The inspection string.
     def inspect
       inspection = inspectables.inject( [] ) { |r, c| r << "#{c}: #{send(c).inspect}" }
       "#<#{self.class.name} #{inspection * ', '}, adapters: #{@adapters.map(&:inspect) * ', '}>"
     end
 
+    # @private
+    def close
+      @adapters.each(&:close)
+    end
+
+    # @private
+    def adapters
+      @adapters
+    end
+
     private
 
-    # The :adapters key may be passed to the options hash. It may appear in 
+    # The :adapters key may be passed to the options hash. It may appear in
     # multiple variations:
     #
     # @example
@@ -147,11 +177,11 @@ module Yell #:nodoc:
     #
     # @example
     #   options = { :adapters => [:stdout => {:level => :info}, :stderr => {:level => :error}]
-    def _extract_adapters!( opts )
-      ( opts.delete( :adapters ) || [] ).each do |a|
+    def extract!( opts )
+      ( opts.delete(:adapters) || [] ).each do |a|
         case a
-          when String, Symbol then adapter( a )
-          else a.each { |n, o| adapter( n, o || {} ) }
+        when String, Symbol then adapter( a )
+        else a.each { |n, o| adapter( n, o || {} ) }
         end
       end
     end
@@ -162,10 +192,8 @@ module Yell #:nodoc:
     end
 
     # Get an array of inspected attributes for the adapter.
-    #
-    # @return [ String ] An array of pretty printed field values.
     def inspectables
-      [ :name, :level ]
+      [ :name, :level, :trace ]
     end
 
   end

data/lib/yell/version.rb

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

data/spec/yell/adapters/base_spec.rb

@@ -10,7 +10,7 @@ describe Yell::Adapters::Base do
     end
 
     it "should set the level" do
-      Yell::Adapters::Base.new :level => :info
+      Yell::Adapters::Base.new(:level => :info)
     end
   end
 
@@ -23,23 +23,24 @@ describe Yell::Adapters::Base do
       end
 
       it "should set the level" do
-        Yell::Adapters::Base.new :level => :info
+        Yell::Adapters::Base.new(:level => :info)
       end
     end
   end
 
   context :options do
-    let( :options ) { { :my => :options } }
-    let( :adapter ) { Yell::Adapters::Base.new( options ) }
+    let(:options) { {:my => :options} }
+    let(:adapter) { Yell::Adapters::Base.new(options) }
 
     it { options.should == options }
   end
 
   context :write do
-    subject { Yell::Adapters::Base.new :level => :info }
+    let(:logger) { Yell::Logger.new }
+    subject { Yell::Adapters::Base.new(:level => 1) }
 
     it "should delegate :event to :write!" do
-      event = Yell::Event.new( 1, "Hello World!" )
+      event = Yell::Event.new( logger, 1, "Hello World!" )
 
       mock( subject ).write!( event )
 
@@ -47,7 +48,7 @@ describe Yell::Adapters::Base do
     end
 
     it "should not write when event does not have the right level" do
-      event = Yell::Event.new( 0, "Hello World!" )
+      event = Yell::Event.new( logger, 0, "Hello World!" )
 
       dont_allow( subject ).write!( event )
 

data/spec/yell/adapters/datefile_spec.rb

@@ -1,15 +1,18 @@
 require 'spec_helper'
 
 describe Yell::Adapters::Datefile do
-  let( :filename ) { fixture_path + '/test.log' }
-  let( :event ) { Yell::Event.new(1, "Hello World") }
+  let(:logger) { Yell::Logger.new }
+  let(:filename) { fixture_path + '/test.log' }
+  let(:event) { Yell::Event.new(logger, 1, "Hello World") }
 
   before do
     Timecop.freeze( Time.now )
   end
 
+  it { should be_kind_of Yell::Adapters::File }
+
   describe :filename do
-    let( :adapter ) { Yell::Adapters::Datefile.new(:filename => filename, :symlink => false) }
+    let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename, :symlink => false) }
 
     it "should be replaced with date_pattern" do
       adapter.write( event )
@@ -21,12 +24,12 @@ describe Yell::Adapters::Datefile do
       mock( File ).open( datefile_filename, anything ) { File.new('/dev/null', 'w') }
 
       adapter.write( event )
-      Timecop.freeze( Time.now + 10 ) { adapter.write( event ) }
+      Timecop.freeze( Time.now + 10 ) { adapter.write(event) }
     end
 
     context "rollover" do
-      let( :tomorrow ) { Time.now + 86400 }
-      let( :tomorrow_datefile_filename ) { fixture_path + "/test.#{tomorrow.strftime(Yell::Adapters::Datefile::DefaultDatePattern)}.log" }
+      let(:tomorrow) { Time.now + 86400 }
+      let(:tomorrow_datefile_filename) { fixture_path + "/test.#{tomorrow.strftime(Yell::Adapters::Datefile::DefaultDatePattern)}.log" }
 
       it "should rotate when date has passed" do
         mock( File ).open( datefile_filename, anything ) { File.new('/dev/null', 'w') }
@@ -41,7 +44,7 @@ describe Yell::Adapters::Datefile do
   end
 
   describe :keep do
-    let( :adapter ) { Yell::Adapters::Datefile.new(:keep => 2, :filename => filename, :symlink => false, :date_pattern => "%M") }
+    let(:adapter) { Yell::Adapters::Datefile.new(:keep => 2, :filename => filename, :symlink => false, :date_pattern => "%M") }
 
     it "should keep the specified number or files upon rollover" do
       adapter.write( event )
@@ -60,17 +63,17 @@ describe Yell::Adapters::Datefile do
   end
 
   describe :symlink do
-    let( :time ) { Time.now }
+    let(:time) { Time.now }
     before { Timecop.freeze(time) }
 
     context "default (true)" do
-      let( :adapter ) { Yell::Adapters::Datefile.new(:filename => filename, :date_pattern => "%M") }
+      let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename, :date_pattern => "%M") }
 
       it "should create the sylink the original filename" do
         adapter.write( event )
 
         File.symlink?( filename ).should be_true
-        File.readlink( filename ).should == datefile_filename( adapter.date_pattern )
+        File.readlink( filename ).should == datefile_filename(adapter.date_pattern)
       end
 
       it "should symlink upon rollover" do
@@ -80,13 +83,13 @@ describe Yell::Adapters::Datefile do
           adapter.write( event )
 
           File.symlink?( filename ).should be_true
-          File.readlink( filename ).should == datefile_filename( adapter.date_pattern )
+          File.readlink( filename ).should == datefile_filename(adapter.date_pattern)
         end
       end
     end
 
     context "when set to false" do
-      let( :adapter ) { Yell::Adapters::Datefile.new(:symlink => false, :filename => filename, :date_pattern => "%M") }
+      let(:adapter) { Yell::Adapters::Datefile.new(:symlink => false, :filename => filename, :date_pattern => "%M") }
 
       it "should not create the sylink the original filename" do
         adapter.write( event )
@@ -97,8 +100,8 @@ describe Yell::Adapters::Datefile do
   end
 
   describe :header do
-    let( :adapter ) { Yell::Adapters::Datefile.new(:filename => filename) }
-    let( :header ) { File.open(datefile_filename, &:readline) }
+    let(:adapter) { Yell::Adapters::Datefile.new(:filename => filename) }
+    let(:header) { File.open(datefile_filename, &:readline) }
 
     before do
       adapter.format = "%m" # easier to parse

data/spec/yell/adapters/file_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Yell::Adapters::File do
-  let( :devnull ) { File.new('/dev/null', 'w') }
+  let(:devnull) { File.new('/dev/null', 'w') }
 
   before do
     stub( File ).open( anything, anything ) { devnull }
@@ -16,11 +16,12 @@ describe Yell::Adapters::File do
   end
 
   context :write do
-    let( :event ) { Yell::Event.new(1, "Hello World") }
+    let(:logger) { Yell::Logger.new }
+    let(:event) { Yell::Event.new(logger, 1, "Hello World") }
 
     context "default filename" do
-      let( :filename ) { File.expand_path "#{Yell.env}.log" }
-      let( :adapter ) { Yell::Adapters::File.new }
+      let(:filename) { File.expand_path "#{Yell.env}.log" }
+      let(:adapter) { Yell::Adapters::File.new }
 
       it "should print to file" do
         mock( File ).open( filename, File::WRONLY|File::APPEND|File::CREAT ) { devnull }
@@ -30,8 +31,8 @@ describe Yell::Adapters::File do
     end
 
     context "with given :filename" do
-      let( :filename ) { fixture_path + '/filename.log' }
-      let( :adapter ) { Yell::Adapters::File.new( :filename => filename ) }
+      let(:filename) { fixture_path + '/filename.log' }
+      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 }
@@ -41,8 +42,8 @@ describe Yell::Adapters::File do
     end
 
     context "with given :pathname" do
-      let( :pathname ) { Pathname.new(fixture_path).join('filename.log') }
-      let( :adapter ) { Yell::Adapters::File.new( :filename => pathname ) }
+      let(:pathname) { Pathname.new(fixture_path).join('filename.log') }
+      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 }
@@ -52,7 +53,7 @@ describe Yell::Adapters::File do
     end
 
     context :sync do
-      let( :adapter ) { Yell::Adapters::File.new }
+      let(:adapter) { Yell::Adapters::File.new }
 
       it "should sync by default" do
         mock( devnull ).sync=( true )

data/spec/yell/adapters/io_spec.rb

@@ -8,14 +8,14 @@ describe Yell::Adapters::Io do
     it "should set default :format" do
       adapter = Yell::Adapters::Io.new
 
-      adapter.format.should be_kind_of Yell::Formatter
+      adapter.format.should be_kind_of(Yell::Formatter)
     end
 
     context :level do
-      let( :level ) { Yell::Level.new(:warn) }
+      let(:level) { Yell::Level.new(:warn) }
 
       it "should set the level" do
-        adapter = Yell::Adapters::Io.new :level => level
+        adapter = Yell::Adapters::Io.new(:level => level)
         adapter.level.should == level
       end
 
@@ -26,10 +26,10 @@ describe Yell::Adapters::Io do
     end
 
     context :format do
-      let( :format ) { Yell::Formatter.new }
+      let(:format) { Yell::Formatter.new }
 
       it "should set the level" do
-        adapter = Yell::Adapters::Io.new :format => format
+        adapter = Yell::Adapters::Io.new(:format => format)
         adapter.format.should == format
       end
 
@@ -41,9 +41,10 @@ describe Yell::Adapters::Io do
   end
 
   context :write do
-    let( :event ) { Yell::Event.new(1, "Hello World") }
-    let( :adapter ) { Yell::Adapters::Io.new }
-    let( :stream ) { File.new('/dev/null', 'w') }
+    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 }

data/spec/yell/adapters_spec.rb

@@ -4,7 +4,7 @@ describe Yell::Adapters do
 
   context :new do
     context "given a Yell::Adapters::Base ancestor" do
-      let( :stdout ) { Yell::Adapters::Stdout.new }
+      let(:stdout) { Yell::Adapters::Stdout.new }
 
       it "should return the instance" do
         Yell::Adapters.new( stdout ).should == stdout
@@ -35,8 +35,8 @@ describe Yell::Adapters do
   end
 
   context :register do
-    let( :name ) { :test }
-    let( :klass ) { mock }
+    let(:name) { :test }
+    let(:klass) { mock }
 
     before { Yell::Adapters.register( name, klass ) }
 

data/spec/yell/configuration_spec.rb

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

data/spec/yell/event_spec.rb

@@ -4,39 +4,21 @@ require 'spec_helper'
 # the logger methods, we need to divert here in order to get 
 # the correct caller.
 class EventFactory
-  def self.event( level, message )
-    self._event( level, message )
+  def self.event(logger, level, message)
+    self._event(logger, level, message)
   end
 
   private
 
-  def self._event( level, message )
-    Yell::Event.new level, message
+  def self._event(logger, level, message)
+    Yell::Event.new(logger, level, message)
   end
 
 end
 
 describe Yell::Event do
-  let(:event) { Yell::Event.new 1, 'Hello World!' }
-
-  context :caller do
-    let( :event ) { EventFactory.event 1, "Hello World" }
-
-    context :file do
-      subject { event.file }
-      it  { should == __FILE__ }
-    end
-
-    context :line do
-      subject { event.line }
-      it { should == "8" }
-    end
-
-    context :method do
-      subject { event.method }
-      it { should == 'event' }
-    end
-  end
+  let(:logger) { Yell::Logger.new(:trace => true) }
+  let(:event) { Yell::Event.new(logger, 1, 'Hello World!') }
 
   context :level do
     subject { event.level }
@@ -77,7 +59,7 @@ describe Yell::Event do
       read, write = IO.pipe
 
       @pid = Process.fork do
-        event = Yell::Event.new 1, 'Hello World!'
+        event = Yell::Event.new(logger, 1, 'Hello World!')
         write.puts event.pid
       end
       Process.wait
@@ -96,4 +78,22 @@ describe Yell::Event do
     it { should == $0 }
   end
 
+  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" }
+    end
+
+    context "without trace" do
+      before { logger.trace = false }
+
+      its(:file) { should == "" }
+      its(:line) { should == "" }
+      its(:method) { should == "" }
+    end
+  end
+
 end

data/spec/yell/formatter_spec.rb

@@ -2,11 +2,12 @@ require 'spec_helper'
 
 describe Yell::Formatter do
 
-  let( :formatter ) { Yell::Formatter.new(subject) }
-  let( :event ) { Yell::Event.new 1, 'Hello World!' }
-  let( :time ) { Time.now }
+  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(:format) { formatter.format(event) }
 
   before do
     Timecop.freeze( time )
@@ -52,7 +53,7 @@ describe Yell::Formatter do
   end
 
   context "caller" do
-    let( :_caller ) { [nil, nil, "/path/to/file.rb:123:in `test_method'"] }
+    let(:_caller) { [nil, nil, "/path/to/file.rb:123:in `test_method'"] }
 
     before do
       any_instance_of( Yell::Event ) do |e|
@@ -104,8 +105,8 @@ describe Yell::Formatter do
   end
 
   context "Exceptions" do
-    let( :exception ) { StandardError.new( "This is an Exception" ) }
-    let( :event ) { Yell::Event.new( 1, exception ) }
+    let(:exception) { StandardError.new( "This is an Exception" ) }
+    let(:event) { Yell::Event.new(logger, 1, exception) }
 
     subject { "%m" }
 
@@ -117,8 +118,8 @@ describe Yell::Formatter do
   end
 
   context "Hashes" do
-    let( :hash ) { { :test => 'message' } }
-    let( :event ) { Yell::Event.new( 1, hash ) }
+    let(:hash) { { :test => 'message' } }
+    let(:event) { Yell::Event.new(logger, 1, hash) }
 
     subject { "%m" }
 

data/spec/yell/level_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Yell::Level do
 
   context "default" do
-    let( :level ) { Yell::Level.new }
+    let(:level) { Yell::Level.new }
 
     it { level.at?(:debug).should be_true }
     it { level.at?(:info).should be_true }
@@ -13,7 +13,7 @@ describe Yell::Level do
   end
 
   context "given a Symbol" do
-    let( :level ) { Yell::Level.new(subject) }
+    let(:level) { Yell::Level.new(subject) }
 
     context :debug do
       subject { :debug }
@@ -67,7 +67,7 @@ describe Yell::Level do
   end
 
   context "given a String" do
-    let( :level ) { Yell::Level.new(subject) }
+    let(:level) { Yell::Level.new(subject) }
 
     context "basic string" do
       subject { 'error' }
@@ -131,7 +131,7 @@ describe Yell::Level do
   end
 
   context "given an Array" do
-    let( :level ) { Yell::Level.new( [:debug, :warn, :fatal] ) }
+    let(:level) { Yell::Level.new( [:debug, :warn, :fatal] ) }
 
     it { level.at?(:debug).should be_true }
     it { level.at?(:info).should be_false }
@@ -141,7 +141,7 @@ describe Yell::Level do
   end
 
   context "given a Range" do
-    let( :level ) { Yell::Level.new( (1..3) ) }
+    let(:level) { Yell::Level.new( (1..3) ) }
 
     it { level.at?(:debug).should be_false }
     it { level.at?(:info).should be_true }
@@ -151,7 +151,7 @@ describe Yell::Level do
   end
 
   context "given a Yell::Level instance" do
-    let( :level ) { Yell::Level.new( :warn ) }
+    let(:level) { Yell::Level.new(:warn) }
 
     it { level.at?(:debug).should be_false }
     it { level.at?(:info).should be_false }
@@ -161,7 +161,7 @@ describe Yell::Level do
   end
 
   context "backwards compatibility" do
-    let( :level ) { Yell::Level.new :warn }
+    let(:level) { Yell::Level.new :warn }
 
     it { level.to_i.should == 2 }
     it { Integer(level).should == 2 }

data/spec/yell/logger_spec.rb

@@ -13,10 +13,12 @@ class LoggerFactory
 end
 
 describe Yell::Logger do
-  let( :filename ) { fixture_path + '/logger.log' }
+  let(:filename) { fixture_path + '/logger.log' }
 
   context "a Logger instance" do
-    let( :logger ) { Yell::Logger.new }
+    let(:logger) { Yell::Logger.new }
+
+    its(:name) { should be_nil }
 
     context "log methods" do
       subject { logger }
@@ -41,23 +43,43 @@ describe Yell::Logger do
     end
 
     context "default adapter" do
-      let( :adapters ) { logger.instance_variable_get :@adapters }
+      let(:adapters) { logger.instance_variable_get(:@adapters) }
 
       it { adapters.size.should == 1 }
-      it { adapters.first.should be_kind_of Yell::Adapters::File }
+      it { adapters.first.should be_kind_of(Yell::Adapters::File) }
+    end
+
+    context "default :level" do
+      subject { logger.level }
+
+      it { should be_instance_of(Yell::Level) }
+      its(:severities) { should == [true, true, true, true, true, true] }
+    end
+
+    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
     end
   end
 
   context "initialize with a :name" do
-    let( :name ) { 'test' }
+    let(:name) { 'test' }
+    let!(:logger) { Yell.new(:name => name) }
 
-    it "should be added to the repository" do
-      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
     end
   end
 
+  context "initialize with :trace" do
+  end
+
   context "initialize with a :filename" do
     it "should call adapter with :file" do
       mock.proxy( Yell::Adapters::File ).new( :filename => 'test.log' )
@@ -103,36 +125,39 @@ describe Yell::Logger do
   end
 
   context "initialize with a block" do
-    let( :level ) { Yell::Level.new :error }
-    let( :adapter ) { Yell::Adapters::Stdout.new }
+    let(:level) { Yell::Level.new :error }
+    let(:stdout) { Yell::Adapters::Stdout.new }
+    let(:adapters) { loggr.instance_variable_get(:@adapters) }
 
-    let( :logger ) do
-      Yell::Logger.new do |l|
-        l.level = level
-        l.adapter adapter
+    context "with arity" do
+      subject do
+        Yell::Logger.new(:level => level) { |l| l.adapter(:stdout) }
       end
-    end
 
-    it "should set the level" do
-      logger.level.should == level
+      its(:level) { should == level }
+      its('adapters.size') { should == 1 }
+      its('adapters.first') { should be_instance_of(Yell::Adapters::Stdout) }
     end
 
-    it "should define adapter" do
-      adapters = logger.instance_variable_get :@adapters
+    context "without arity" do
+      subject do
+        Yell::Logger.new(:level => level) { adapter(:stdout) }
+      end
 
-      adapters.size.should == 1
-      adapters.first.should == adapter
+      its(:level) { should == level }
+      its('adapters.size') { should == 1 }
+      its('adapters.first') { should be_instance_of(Yell::Adapters::Stdout) }
     end
   end
 
   context "initialize with :adapters option" do
-    let( :logger ) do
+    let(:logger) do
       Yell::Logger.new :adapters => [ :stdout, { :stderr => {:level => :error} } ]
     end
 
-    let( :adapters ) { logger.instance_variable_get :@adapters }
-    let( :stdout ) { adapters.first }
-    let( :stderr ) { adapters.last }
+    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
@@ -149,24 +174,24 @@ describe Yell::Logger do
   end
 
   context "caller's :file, :line and :method" do
-    let( :adapter ) { Yell::Adapters::Stdout.new :format => "%F, %n: %M" }
-    let( :logger ) { Yell::Logger.new { |l| l.adapter adapter } }
+    let(:stdout) { Yell::Adapters::Stdout.new(:format => "%F, %n: %M") }
+    let(:logger) { Yell::Logger.new(:trace => true) { |l| l.adapter(stdout) } }
 
     it "should write correctly" do
       factory = LoggerFactory.new
       factory.logger = logger
 
-      mock( adapter.send(:stream) ).syswrite( "#{__FILE__}, 7: foo\n" )
-      mock( adapter.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
     end
   end
 
-  context "logging" do
-    let( :logger ) { Yell::Logger.new(filename, :format => "%m") }
-    let( :line ) { File.open(filename, &:readline) }
+  context "logging in general" do
+    let(:logger) { Yell::Logger.new(filename, :format => "%m") }
+    let(:line) { File.open(filename, &:readline) }
 
     it "should output a single message" do
       logger.info "Hello World"

data/spec/yell/repository_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Yell::Repository do
-  let( :name ) { 'test' }
-  let( :logger ) { Yell.new :stdout }
+  let(:name) { 'test' }
+  let(:logger) { Yell.new :stdout }
 
   subject { Yell::Repository[name] }
 
@@ -56,8 +56,8 @@ describe Yell::Repository do
   end
 
   context "[]= with a named logger of other name" do
-    let( :other ) { 'other' }
-    let( :logger ) { Yell.new :stdout, :name => other }
+    let(:other) { 'other' }
+    let(:logger) { Yell.new :stdout, :name => other }
 
     before do
       Yell::Repository[ name ] = logger
@@ -70,7 +70,7 @@ describe Yell::Repository do
   end
 
   context "loggers" do
-    let( :loggers ) { { name => logger } }
+    let(:loggers) { { name => logger } }
 
     subject { Yell::Repository.loggers }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yell
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-16 00:00:00.000000000 Z
+date: 2013-02-20 00:00:00.000000000 Z
 dependencies: []
 description: Yell - Your Extensible Logging Library. Define multiple adapters, various
   log level combinations or message formatting options like you've never done before
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: yell
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Yell - Your Extensible Logging Library