yell 1.0.0 → 1.1.0

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 
-script: "rake"
+script: "rspec"
 
 rvm:
   - 1.8.7

data/README.md

@@ -107,6 +107,35 @@ Yell['mylog']
 There is no need to define outputters separately and you don't have to taint 
 you global namespace with Yell's subclasses.
 
+### You want any class to have a logger?
+
+Yell comes with a simple module: +Yell::Loggable+. Simply include this in a class and 
+you are good to go.
+
+```ruby
+# Before you can use it, you will need to define a logger and 
+# provide it with the `:name` of your class.
+Yell.new :stdout, :name => 'Foo'
+
+class Foo
+  include Yell::Loggable
+end
+
+# Now you can log
+Foo.new.logger.info "Hello World"
+```
+
+It even works with class inheritance:
+
+```ruby
+# Given the above example, we inherit from Foo
+class Bar < Foo
+end
+
+# The logger will fallback to the Foo superclass
+Bar.new.logger.info "Hello World"
+```
+
 
 ## Further Readings
 

data/Rakefile

@@ -1,42 +1,16 @@
 $LOAD_PATH.unshift( 'lib' )
-
 require 'bundler'
-Bundler::GemHelper.install_tasks
 
+
+# Run stuff in the examples folder
+desc "Run examples"
 task :examples do
   require 'benchmark'
 
   seconds = Benchmark.realtime do
-    Dir[ './examples/*.rb' ].sort.each do |file|
-      begin
-        puts "\n*** Running #{file}"
-
-        require file
-      rescue Exception => e
-        puts "#{e.class}: #{e.message}:\n\t#{e.backtrace.join("\n\t")}"
-
-        exit 1
-      end
-    end
+    Dir[ './examples/*.rb' ].each { |file| puts "\n\n=== Running #{file} ==="; require file }
   end
 
   puts "\n\t[ Examples took #{seconds} seconds to run ]"
 end
 
-# RSpec
-begin
-  require 'rspec/core/rake_task'
-
-  desc "Run specs"
-  RSpec::Core::RakeTask.new do |t|
-    t.rspec_opts = %w(--color --format progress --order random)
-    # t.ruby_opts = %w(-w)
-  end
-rescue LoadError
-  task :spec do
-    abort "`gem install rspec` in order to run tests"
-  end
-end
-
-task :default => :spec
-

data/examples/006.2-the-loggable-module-with-inheritance.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require_relative '../lib/yell'
+
+puts <<-EOS
+
+# You can add logging to any class by including the Yell::Loggable module.
+#
+# When including the module, your class will get a :logger method. Before you
+# can use it, though, you will need to define a logger providing the :name of
+# your class.
+
+Yell.new :stdout, :name => 'Foo'
+
+# Define the class
+class Foo
+  include Yell::Loggable
+end
+
+class Bar < Foo; end
+
+bar = Bar.new
+bar.logger.info "Hello World!"
+#=> "2012-02-29T09:30:00+01:00 [ INFO] 65784 : Hello World!"
+
+
+EOS
+
+puts "=== actual example ==="
+
+Yell.new :stdout, :name => 'Foo'
+
+class Foo
+  include Yell::Loggable
+end
+
+class Bar < Foo; end
+
+bar = Bar.new
+bar.logger.info "Hello World!"
+

data/lib/yell/adapters/base.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'thread'
+require 'monitor'
 
 module Yell #:nodoc:
   module Adapters #:nodoc:
@@ -40,7 +40,7 @@ module Yell #:nodoc:
     #
     #   logger = Yell.new :puts
     #   logger.info "Hello World!"
-    class Base
+    class Base < Monitor
       include Yell::Level::Helpers
 
       class << self
@@ -125,7 +125,7 @@ module Yell #:nodoc:
       #
       # You should not overload the constructor, use #setup instead.
       def initialize( options = {}, &block )
-        @mutex = Mutex.new
+        super() # init the monitor superclass
 
         setup!(options)
         block.call(self) if block
@@ -191,10 +191,6 @@ module Yell #:nodoc:
         @level.nil? || @level.at?( event.level )
       end
 
-      def synchronize( &block )
-        @mutex.synchronize( &block )
-      end
-
     end
 
   end

data/lib/yell/adapters/datefile.rb

@@ -4,50 +4,53 @@ module Yell #:nodoc:
   module Adapters #:nodoc:
 
     # The +Datefile+ adapter is similar to the +File+ adapter. However, it
-    # rotates the file at midnight.
+    # rotates the file at midnight (by default).
     class Datefile < Yell::Adapters::File
 
       # The default date pattern, e.g. "19820114" (14 Jan 1982)
       DefaultDatePattern = "%Y%m%d"
 
       # Metadata
-      Metadata = lambda { |date, pattern| "# -*- #{date.iso8601} (#{date.to_f}) [#{pattern}] -*-" }
-      MetadataRegexp = /^# -\*- (.+) \((\d+\.\d+)\) \[(.+)\] -\*-$/
+      Header = lambda { |date, pattern| "# -*- #{date.iso8601} (#{date.to_f}) [#{pattern}] -*-" }
+      HeaderRegexp = /^# -\*- (.+) \((\d+\.\d+)\) \[(.+)\] -\*-$/
 
 
       setup do |options|
         @date, @date_strftime = nil, nil # default; do not override --R
 
+        # check whether to write the log header (default true)
+        self.header = options.fetch(:header, true)
+
+        # check the date pattern on the filename (default "%Y%m%d")
         self.date_pattern = options.fetch(:date_pattern, DefaultDatePattern)
-        self.keep = options.fetch(:keep, 0)
-
-        self.symlink = if options.key?(:symlink_original_filename)
-          Yell._deprecate( "0.13.3", "Use :symlink for symlinking to oriinal filename",
-            :before => "Yell.new { |l| l.adapter :datefile, :symlink_original_filename => true }",
-            :after => "Yell.new { |l| l.adapter :datefile, :symlink => true }"
-          )
-          options.fetch(:symlink_original_filename, false)
-        else
-          options.fetch(:symlink, false)
-        end
+
+        # check whether to cleanup old files of the same pattern (default false)
+        self.keep = options.fetch(:keep, false)
+
+        # check whether to symlink the otiginal filename (default false)
+        self.symlink = options.fetch(:symlink, false)
 
         @original_filename  = ::File.expand_path options.fetch(:filename, default_filename)
         options[:filename]  = @original_filename
       end
 
       write do |event|
-        return unless close? # do nothing when not closing
+        # do nothing when not closing
+        return unless close?
         close
 
-        cleanup! if cleanup?
-        symlink! if symlink?
+        # exit when file ready present
+        return if ::File.exist?( @filename )
+
+        # write the header if applicable
+        stream.puts( Header.call(@date, date_pattern) ) if header?
 
-        return if ::File.exist?( @filename ) # exit when file ready present
-        stream.puts( Metadata.call(@date, date_pattern) )
+        symlink! if symlink?
+        cleanup! if cleanup?
       end
 
       close do
-        @filename = filename_from( @date )
+        @filename = filename_for( @date )
       end
 
 
@@ -77,6 +80,15 @@ module Yell #:nodoc:
       #   keep = 0
       attr_accessor :keep
 
+      # You can suppress the first line of the logfile that contains
+      # the metadata. This is important upon rollover, because on *nix 
+      # systems, it is not possible to determine the creation time of a file, 
+      # on the last access time. The header compensates this.
+      #
+      # @example
+      #   header = false
+      attr_accessor :header
+
 
       private
 
@@ -92,27 +104,39 @@ module Yell #:nodoc:
 
         if @stream.nil? or _date_strftime != @date_strftime
           @date, @date_strftime = _date, _date_strftime
+
           return true
         end
 
         false
       end
 
-      # Cleanup old files
+      # Removes old logfiles of the same date pattern.
+      #
+      # By reading the header of the files that match the date pattern, the
+      # adapter determines whether to remove them or not. If no header is present, 
+      # it makes the best guess by checking the last access time (which may result 
+      # in false cleanups).
       def cleanup!
-        files = Dir[ @original_filename.sub( /(\.\w+)?$/, ".*\\1" ) ].map do |f|
-          [ f, metadata_from(f).last ]
-        end.select do |(_, p)|
-          date_pattern == p
+        files = Dir[ @original_filename.sub( /(\.\w+)?$/, ".*\\1" ) ].sort.select do |file|
+          created, pattern = header_from(file)
+
+          # Select if the date pattern is nil (no header info available within the file) or
+          # when the pattern matches.
+          pattern.nil? || pattern == self.date_pattern
         end
 
-        ::File.unlink( *files.map(&:first)[0..-keep] )
+        ::File.unlink( *files[0..-keep-1] )
       end
 
+      # Cleanup old logfiles?
+      #
+      # @return [Boolean] true or false
       def cleanup?
-        keep.to_i > 0
+        !!keep && keep.to_i > 0
       end
 
+      # Symlink the current filename to the original one.
       def symlink!
         # do nothing, because symlink is already correct
         return if ::File.symlink?(@original_filename) && ::File.readlink(@original_filename) == @filename
@@ -121,20 +145,32 @@ module Yell #:nodoc:
         ::File.symlink( @filename, @original_filename )
       end
 
-      def symlink?
-        !!symlink
-      end
+      # Symlink the original filename?
+      #
+      # @return [Boolean] true or false
+      def symlink?; !!symlink; end
+
+      # Write header into the file?
+      #
+      # @return [Boolean] true or false
+      def header?; !!header; end
 
       # Sets the filename with the `:date_pattern` appended to it.
-      def filename_from( date )
+      def filename_for( date )
         @original_filename.sub( /(\.\w+)?$/, ".#{date.strftime(date_pattern)}\\1" )
       end
 
-      def metadata_from( file )
-        if m = ::File.open( file, &:readline ).match( MetadataRegexp )
+      # Fetch the header form the file
+      def header_from( file )
+        if m = ::File.open( file, &:readline ).match( HeaderRegexp )
+          # in case there is a Header present, we can just read from it
           [ Time.at( m[2].to_f ), m[3] ]
         else
-          [ ::File.mtime( file ), "" ]
+          # In case there is no header: we need to take a good guess
+          #
+          # Since the pattern can not be determined, we will just return the Posix ctime. 
+          # That is NOT the creatint time, so the value will potentially be wrong!
+          [ ::File.ctime(file), nil ]
         end
       end
 

data/lib/yell/adapters/file.rb

@@ -9,19 +9,29 @@ module Yell #:nodoc:
 
       setup do |options|
         @filename = ::File.expand_path options.fetch(:filename, default_filename)
+
+        # sync immediately to IO (or not)
+        self.sync = options.fetch(:sync, true)
       end
 
 
+      # Sets the “sync mode” to true or false.
+      #
+      # When true (default), every log event is immediately written to the file. 
+      # When false, the log event is buffered internally.
+      attr_accessor :sync
+
+
       private
 
       # @overload Lazily open the file handle
       def stream
-        @stream or open!
+        synchronize { @stream or open! }
       end
 
       def open!
         @stream = ::File.open( @filename, ::File::WRONLY|::File::APPEND|::File::CREAT )
-        @stream.sync = true
+        @stream.sync = sync
 
         @stream
       end

data/lib/yell/adapters/io.rb

@@ -20,8 +20,8 @@ module Yell #:nodoc:
       setup do |options|
         @stream = nil
 
-        self.colors = options[:colors]
-        self.format = options[:format]
+        self.colors = options.fetch(:colors, false)
+        self.format = options.fetch(:format, nil)
       end
 
       write do |event|
@@ -32,7 +32,8 @@ module Yell #:nodoc:
           message = color + message + Colors[-1]
         end
 
-        message << "\n" unless message[-1] == ?\n # add new line if there is none
+        # add new line if there is none
+        message << "\n" unless message[-1] == ?\n
 
         stream.write( message )
       end
@@ -43,9 +44,19 @@ module Yell #:nodoc:
       end
 
 
+      # Sets colored output on or off (default off)
+      #
+      # @example Enable colors
+      #   colors = true
+      #
+      # @example Disable colors
+      #   colors = false
       attr_accessor :colors
 
-      # Shortcut to enable colors
+      # Shortcut to enable colors.
+      #
+      # @example
+      #   colorize!
       def colorize!; @colors = true; end
 
 

data/lib/yell/event.rb

@@ -22,11 +22,8 @@ module Yell #:nodoc:
     # Accessor to the log level
     attr_reader :level
 
-    # Accessor to the log message
-    attr_reader :message
-
-    # Accessor to additional options
-    attr_reader :options
+    # Accessor to the log messages
+    attr_reader :messages
 
     # Accessor to the time the log event occured
     attr_reader :time
@@ -35,11 +32,12 @@ module Yell #:nodoc:
     attr_reader :thread_id
 
 
-    def initialize( level, message = nil, options = {}, &block )
+    def initialize( level, *messages, &block )
       @time     = Time.now
       @level    = level
-      @message  = block ? block.call : message
-      @options  = options
+
+      @messages = messages
+      @messages << block.call if block
 
       @thread_id  = Thread.current.object_id
 

data/lib/yell/formatter.rb

@@ -61,8 +61,7 @@ module Yell #:nodoc:
     end
 
     PatternTable = {
-      "m" => "message(event.message)",     # Message
-      "o" => "message(event.options)",     # Message options
+      "m" => "message(*event.messages)",   # Message
       "l" => "level(event.level)[0,1]",    # Level (short), e.g.'I', 'W'
       "L" => "level(event.level)",         # Level, e.g. 'INFO', 'WARN'
       "d" => "date(event.time)",           # ISO8601 Timestamp
@@ -116,7 +115,19 @@ module Yell #:nodoc:
       -
     end
 
-    def message( m )
+    def level( l )
+      Yell::Severities[ l ]
+    end
+
+    def date( t )
+      @date_pattern ? t.strftime( @date_pattern ) : t.iso8601
+    end
+
+    def message( *messages )
+      messages.map { |m| to_message(m) }.join(" ")
+    end
+
+    def to_message( m )
       case m
         when Hash
           m.map { |k,v| "#{k}: #{v}" }.join( ", " )
@@ -124,18 +135,11 @@ module Yell #:nodoc:
           backtrace = m.backtrace ? "\n\t#{m.backtrace.join("\n\t")}" : ""
 
           "%s: %s%s" % [m.class, m.message, backtrace]
-        else m
+        else
+          m
       end
     end
 
-    def level( l )
-      Yell::Severities[ l ]
-    end
-
-    def date( t )
-      @date_pattern ? t.strftime( @date_pattern ) : t.iso8601
-    end
-
   end
 end
 

data/lib/yell/logger.rb

@@ -34,7 +34,7 @@ module Yell #:nodoc:
     #   Yell::Logger.new :datefile, 'development.log' do |l|
     #     l.level = :info
     #   end
-    def initialize( *args, &block )
+    def initialize( *args )
       @adapters = []
 
       # extract options
@@ -58,7 +58,7 @@ module Yell #:nodoc:
       self.adapter args.pop if args.any?
 
       # eval the given block
-      _call( &block ) if block
+      yield(self) if block_given?
 
       # default adapter when none defined
       self.adapter :file if @adapters.empty?
@@ -98,21 +98,6 @@ module Yell #:nodoc:
       Yell::Repository[val] = self
     end
 
-    # Deprecated: Use attr_reader in future
-    def level( val = nil )
-      if val.nil?
-        @level
-      else
-        # deprecated, but should still work
-        Yell._deprecate( "0.5.0", "Use :level= for setting the log level",
-          :before => "Yell::Logger.new { level :info }",
-          :after  => "Yell::Logger.new { |l| l.level = :info }"
-        )
-
-        @level = Yell::Level.new( val )
-      end
-    end
-
     # Convenience method for resetting all adapters of the Logger.
     def close
       @adapters.each(&:close)
@@ -128,34 +113,20 @@ 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 = nil, o = {}, &b )          # def info( m = nil, o = {}, &b )
-          return false unless #{name}?              #   return false unless info?
-          write Yell::Event.new(#{index}, m, o, &b) #   write Yell::Event.new(1, m, o, &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(#{index}, *m, &b) #   write Yell::Event.new(1, *m, &b)
+                                                  #
+          true                                    #   true
+        end                                       # end
       EOS
     end
 
 
     private
 
-    def _call( &block )
-      if block.arity == 0
-        Yell._deprecate( "0.5.0", "Yell::Logger.new with block expects argument now",
-          :before => "Yell::Logger.new { adapter STDOUT }",
-          :after  => "Yell::Logger.new { |l| l.adapter STDOUT }"
-        )
-
-        # deprecated, but should still work
-        instance_eval( &block )
-      else
-        block.call(self)
-      end
-    end
-
     # The :adapters key may be passed to the options hash. It may appear in 
     # multiple variations:
     #

data/lib/yell/repository.rb

@@ -19,40 +19,50 @@ module Yell #:nodoc:
       @loggers = {}
     end
 
-    # Set loggers in the repository
-    #
-    # @example Set a logger
-    #   Yell::Repository[ 'development' ] = Yell::Logger.new :stdout
-    #
-    # @return [Yell::Logger] The logger instance
-    def self.[]=( name, logger )
-      synchronize { instance.loggers[name] = logger }
-    end
-
-    # Get loggers from the repository
-    #
-    # @example Get the logger
-    #   Yell::Repository[ 'development' ]
-    #
-    # @raise [Yell::LoggerNotFound] Raised when repository does not have that key
-    # @return [Yell::Logger] The logger instance
-    def self.[]( name )
-      synchronize do
-        logger = instance.loggers[name] || instance.loggers[name.to_s]
+    class << self
+      # Set loggers in the repository
+      #
+      # @example Set a logger
+      #   Yell::Repository[ 'development' ] = Yell::Logger.new :stdout
+      #
+      # @return [Yell::Logger] The logger instance
+      def []=( name, logger )
+        synchronize { instance.loggers[name] = logger }
+      end
 
-        if logger.nil? && name.respond_to?(:superclass)
-          return Yell::Repository[ name.superclass ]
-        end
+      # Get loggers from the repository
+      #
+      # @example Get the logger
+      #   Yell::Repository[ 'development' ]
+      #
+      # @raise [Yell::LoggerNotFound] Raised when repository does not have that key
+      # @return [Yell::Logger] The logger instance
+      def []( name )
+        synchronize { instance.fetch(name) or raise Yell::LoggerNotFound.new(name) }
+      end
 
-        logger or raise Yell::LoggerNotFound.new(name)
+      # Get the list of all loggers in the repository
+      #
+      # @return [Hash] The map of loggers
+      def loggers
+        synchronize { instance.loggers }
       end
     end
 
-    # Get the list of all loggers in the repository
+
+    # Fetch the logger by the given name.
     #
-    # @return [Hash] The map of loggers
-    def self.loggers
-      synchronize { instance.loggers }
+    # If the logger could not be found and has a superclass, it 
+    # will attempt to look there. This is important for the 
+    # Yell::Loggable module.
+    def fetch( name )
+      logger = loggers[name] || loggers[name.to_s]
+
+      if logger.nil? && name.respond_to?(:superclass)
+        return fetch( name.superclass )
+      end
+
+      logger
     end
 
   end

data/lib/yell/version.rb

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

data/spec/threaded/yell_spec.rb

@@ -2,41 +2,99 @@ require 'spec_helper'
 
 describe "running Yell multi-threaded" do
   let( :threads ) { 100 }
+  let( :range ) { (1..threads) }
 
   let( :filename ) { fixture_path + '/threaded.log' }
   let( :lines ) { `wc -l #{filename}`.to_i }
 
-  it "should write all messages from one instance" do
-    logger = Yell.new( filename )
+  context "one instance" do
+    before do
+      logger = Yell.new filename
 
-    (1..threads).map do |count|
-      Thread.new { 10.times { logger.info count } }
-    end.each(&:join)
+      range.map do |count|
+        Thread.new { 10.times { logger.info count } }
+      end.each(&:join)
 
-    lines.should == 10*threads
+      sleep 0.5
+    end
+
+    it "should write all messages" do
+      lines.should == 10*threads
+    end
   end
 
-  # it "should write all messages from multiple instances" do
-  #   (1..threads).map do |count|
-  #     logger = Yell.new( filename )
+  # context "one instance per thread" do
+  #   before do
+  #     range.map do |count|
+  #       Thread.new do
+  #         logger = Yell.new( filename )
+
+  #         10.times { logger.info count }
+  #       end
+  #     end.each(&:join)
 
-  #     Thread.new do
-  #       10.times { logger.info count }
-  #     end
-  #   end.each(&:join)
+  #     sleep 0.5
+  #   end
 
-  #   lines.should == 10*threads
+  #   it "should write all messages" do
+  #     lines.should == 10*threads
+  #   end
   # end
 
-  it "should write all messages from one repository" do
-    Yell[ 'threaded' ] = Yell.new( filename )
+  context "one instance in the repository" do
+    before do
+      Yell[ 'threaded' ] = Yell.new( filename )
+    end
 
-    (1..threads).map do |count|
-      Thread.new { 10.times { Yell['threaded'].info count } }
-    end.each(&:join)
+    it "should write all messages" do
+      range.map do |count|
+        Thread.new { 10.times { Yell['threaded'].info count } }
+      end.each(&:join)
 
-    lines.should == 10*threads
+      lines.should == 10*threads
+    end
   end
 
+  context "multiple datefile instances" do
+    let( :threadlist ) { [] }
+    let( :date ) { Time.now }
+
+    before do
+      Timecop.freeze( date - 86400 )
+
+      range.each do |count|
+        threadlist << Thread.new do
+          logger = Yell.new :datefile, :filename => filename, :keep => 2
+          loop { logger.info :info; sleep 0.1 }
+        end
+      end
+
+      sleep 0.3 # sleep to get some messages into the file
+    end
+
+    after do
+      threadlist.each(&:kill)
+    end
+
+    it "should safely rollover" do
+      # now cycle the days
+      7.times do |count|
+        Timecop.freeze( date + 86400*count )
+        sleep 0.3
+
+        files = Dir[ fixture_path + '/*.log' ]
+        files.size.should == 2
+
+        # files.last.should match( datefile_pattern_for(Time.now) ) # today
+        # files.first.should match( datefile_pattern_for(Time.now-86400) ) # yesterday
+      end
+    end
+  end
+
+  private
+
+  def datefile_pattern_for( time )
+    time.strftime(Yell::Adapters::Datefile::DefaultDatePattern)
+  end
 end
 

data/spec/yell/adapters/datefile_spec.rb

@@ -80,6 +80,28 @@ describe Yell::Adapters::Datefile do
     end
   end
 
+  describe :header do
+    let( :adapter ) { Yell::Adapters::Datefile.new(:filename => filename) }
+    let( :header ) { File.open(datefile_filename, &:readline) }
+
+    before do
+      adapter.format = "%m" # easier to parse
+    end
+
+    it "should be written by default" do
+      adapter.write( event )
+
+      header.should match(Yell::Adapters::Datefile::HeaderRegexp)
+    end
+
+    it "should not be written when false" do
+      adapter.header = false
+      adapter.write( event )
+
+      header.should == "Hello World\n"
+    end
+  end
+
 
   private
 

data/spec/yell/adapters/file_spec.rb

@@ -30,7 +30,7 @@ describe Yell::Adapters::File do
     end
 
     context "with given filename" do
-      let( :filename ) { File.expand_path 'filename.log' }
+      let( :filename ) { fixture_path + '/filename.log' }
       let( :adapter ) { Yell::Adapters::File.new( :filename => filename ) }
 
       it "should print to file" do
@@ -39,6 +39,24 @@ describe Yell::Adapters::File do
         adapter.write( event )
       end
     end
+
+    context :sync do
+      let( :adapter ) { Yell::Adapters::File.new }
+
+      it "should sync by default" do
+        mock( devnull ).sync=( true )
+
+        adapter.write( event )
+      end
+
+      it "pass the option to File" do
+        adapter.sync = false
+
+        mock( devnull ).sync=( false )
+
+        adapter.write( event )
+      end
+    end
   end
 
 end

data/spec/yell/event_spec.rb

@@ -17,7 +17,7 @@ class EventFactory
 end
 
 describe Yell::Event do
-  let(:event) { Yell::Event.new 1, 'Hello World!', :test => :option }
+  let(:event) { Yell::Event.new 1, 'Hello World!' }
 
   context :caller do
     let( :event ) { EventFactory.event 1, "Hello World" }
@@ -43,14 +43,9 @@ describe Yell::Event do
     it { should == 1 }
   end
 
-  context :message do
-    subject { event.message }
-    it { should == 'Hello World!' }
-  end
-
-  context :options do
-    subject { event.options }
-    it { should == { :test => :option } }
+  context :messages do
+    subject { event.messages }
+    it { should == ['Hello World!'] }
   end
 
   context :time do

data/spec/yell/formatter_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Yell::Formatter do
 
   let( :formatter ) { Yell::Formatter.new(subject) }
-  let( :event ) { Yell::Event.new 1, 'Hello World!', :test => :option }
+  let( :event ) { Yell::Event.new 1, 'Hello World!' }
   let( :time ) { Time.now }
 
   let( :format ) { formatter.format(event) }
@@ -17,11 +17,6 @@ describe Yell::Formatter do
     it { format.should == "Hello World!" }
   end
 
-  context "%o" do
-    subject { "%o" }
-    it { format.should == "test: option" }
-  end
-
   context "%l" do
     subject { "%l" }
     it { format.should == "I" }

data/spec/yell/logger_spec.rb

@@ -13,6 +13,7 @@ class LoggerFactory
 end
 
 describe Yell::Logger do
+  let( :filename ) { fixture_path + '/logger.log' }
 
   context "a Logger instance" do
     let( :logger ) { Yell::Logger.new }
@@ -155,5 +156,35 @@ describe Yell::Logger do
     end
   end
 
+  context "logging" 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"
+      line.should ==  "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"
+    end
+
+    it "should output a hash and message" do
+      logger.info "Hello World", :test => :message
+      line.should == "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"
+    end
+
+    it "should output a hash and block" do
+      logger.info(:test => :message) { "Hello World" }
+      line.should == "test: message Hello World\n"
+    end
+  end
+
 end
 

data/spec/yell/repository_spec.rb

@@ -23,7 +23,9 @@ describe Yell::Repository do
         @logger = Yell.new :stdout, :name => "Numeric"
       end
 
-      it "should raise when not set" do
+      it "should raise with the correct :name when logger not found" do
+        mock.proxy( Yell::LoggerNotFound ).new( String )
+
         lambda { Yell::Repository[ String ] }.should raise_error( Yell::LoggerNotFound )
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yell
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-17 00:00:00.000000000 Z
+date: 2012-10-03 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
@@ -35,6 +35,7 @@ files:
 - examples/004.1-colorizing-the-log-output.rb
 - examples/005.1-repository.rb
 - examples/006.1-the-loggable-module.rb
+- examples/006.2-the-loggable-module-with-inheritance.rb
 - lib/yell.rb
 - lib/yell/adapters.rb
 - lib/yell/adapters/base.rb