yell 0.1.0 → 0.2.0

data/Gemfile

@@ -7,6 +7,6 @@ gemspec
 group :development do
   gem "rake"
 
-  gem "rspec", "~> 2"
+  gem "rspec"
   gem "timecop"
-end
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2011-2012 Rudolf Schmidt
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,64 @@
+Yell - Your Extensible Logging Library
+
+## Installation
+
+System wide:
+
+```console
+gem install yell
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'yell'
+```
+
+## Usage
+On the basics, Yell works just like any other logging library. However, it 
+tries to make your log mesages  more readable. By default, it will format the given 
+message as follows:
+
+```ruby
+logger = Yell.new STDOUT
+
+logger.info "Hello World"
+"2012-02-29T09:30:00+01:00 [ INFO] 65784 : Hello World"
+#^                         ^       ^       ^
+#ISO8601 Timestamp         Level   Pid     message
+```
+
+You can alternate the formatting, or completely disable it altogether. See the 
+next examples for reference:
+
+```ruby
+# No formatting
+logger = Yell.new STDOUT, :format => false
+logger.info "No formatting"
+"No formatting"
+
+# Alternate formatting
+logger = Yell.new STDOUT, :format => "'%m' at %d"
+logger.info "Alternate formatting"
+"'Alternate format' at 2012-02-29T09:30:00+01:00"
+```
+
+As you can see, it basically is just string interpolation with a few reserved 
+captures. You can see the list at #Yell::Formatter.
+
+When no arguments are given, Yell will check for `ENV['RACK_ENV']` and 
+determine the filename from that.
+
+Alternatively, you may define `ENV['YELL_ENV']` to set the filename. If neither 
+`YELL_ENV` or `RACK_ENV` is defined, `'development'` will be the default. Also, if a 
+`log` directory exists, Yell will place the file there (only if you have not passed
+a filename explicitly.
+
+Naturally, if you pass a `:filename` to Yell:
+
+```ruby
+logger = Yell.new 'custom.log'
+```
+
+Copyright © 2011-2012 Rudolf Schmidt, released under the MIT license
+

data/lib/yell.rb

@@ -1,19 +1,58 @@
-module Yell
+# encoding: utf-8
 
-  autoload :Config,     File.dirname(__FILE__) + '/yell/config'
-  autoload :Formatter,  File.dirname(__FILE__) + '/yell/formatter'
-  autoload :Logger,     File.dirname(__FILE__) + '/yell/logger'
-  autoload :Adapters,   File.dirname(__FILE__) + '/yell/adapters'
+# Copyright (c) 2011-2012 Rudolf Schmidt
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-  class NoSuchAdapter < StandardError; end
+require 'time'
 
+$: << File.dirname(__FILE__)
 
-  def self.new( *args, &block )
+require 'yell/formatter'
+require 'yell/adapters'
+require 'yell/level'
+require 'yell/logger'
+
+module Yell #:nodoc:
+  # The possible log levels
+  Severities = [ 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL', 'UNKNOWN' ]
+
+  extend self
+
+  # Creates a new logger instance.
+  #
+  # Refer to #Yell::Loggger for usage.
+  #
+  # @returns [Yell::Logger] The logger instance
+  def new( *args, &block )
     Yell::Logger.new( *args, &block )
   end
-  
-  def self.config
-    @@config ||= Yell::Config.new
+
+
+  def env #:nodoc:
+    ENV['YELL_ENV'] || ENV['RACK_ENV'] || 'development'
+  end
+
+  def level( val = nil ) #:nodoc:
+    Yell::Level.new( val )
   end
 
 end
+

data/lib/yell/adapters.rb

@@ -1,21 +1,57 @@
-module Yell
+# encoding: utf-8
+
+require 'yell/adapters/base'
+require 'yell/adapters/io'
+require 'yell/adapters/file'
+require 'yell/adapters/datefile'
+
+module Yell #:nodoc:
+
+  # NoSuchAdapter is raised whenever you want to instantiate an 
+  # adapter that does not exist.
+  class NoSuchAdapter < StandardError; end
+
+  # This module provides the interface to attaching adapters to
+  # the logger. You should not have to call the corresponding classes
+  # directly.
   module Adapters
+    extend self
 
-    Dir[ ::File.dirname(__FILE__) + '/adapters/*.rb' ].each do |file|
-      autoload ::File.basename(file, '.rb').capitalize, file
-    end
+    # Returns an instance of the given processor type.
+    #
+    # @example A simple file adapter
+    #   Yell::Adapters[ :file ]
+    def []( type, options = {}, &block )
+      # return type if type.instance_of?(Yell::Adapters::)
+
+      if type.instance_of?( ::IO )
+        # should apply to STDOUT, STDERR, File, etc
+        Yell::Adapters::Io.new( type, options, &block )
+      else
+        # any other type
+        adapter = case type
+          when String, Symbol then self.const_get( camelize(type.to_s) )
+          else type
+        end
 
-    # returns an instance of the given processor type
-    def self.new( type, options = {}, &block )
-      klass = case type
-        when String, Symbol then const_get( type.to_s.capitalize )
-        else type
+        adapter.new( options, &block )
       end
-      
-      klass.new( options, &block )
-    rescue NameError => e
-      raise Yell::NoSuchAdapter, "no such adapter #{type.inspect}"
     end
-    
+
+
+    private
+
+    # Simple camelcase converter.
+    #
+    # @example
+    #   camelize("file")
+    #   #=> "File"
+    #
+    #   camelize("date_file")
+    #   #=> "DateFile"
+    def camelize( str )
+      str.capitalize.gsub( /(_\w)/ ) { |match| match.reverse.chop.upcase }
+    end
+
   end
 end

data/lib/yell/adapters/base.rb

@@ -1,72 +1,55 @@
-module Yell::Adapters
-  class Base
+# encoding: utf-8
 
-    attr_reader :name # name of the logger this adapter belongs to
+module Yell #:nodoc:
+  module Adapters #:nodoc:
 
-    # Initialize a new base adapter. Other adapters should inherit from it.
-    def initialize ( options = {}, &block )
-      @block = block
-
-      @name = options[:name] || Yell.config.env
-      @level, @data = '', '' # default
-    end
-
-    def call ( level, msg )
-      reset!(true) if reset? # connect / get a file handle or whatever
-
-      @level, @message = level, msg
-
-      # self.instance_eval &@block if @block
-      @block.call( self ) if @block
-    end
-
-    def message
-      return @message if @message.is_a?( String )
-
-      @message.inspect
-    end
-
-    # Convenience method for resetting the processor.
+    # This class provides the basic interface for all allowed 
+    # operations on any adapter implementation.
     #
-    # @param [true, false] now Perform the reset immediately? (default false)
-    def reset!( now = false )
-      close
-      open if now
-    end
-
-    # Opens the logfile or connection (in case of a database adapter)
-    def open
-      open! unless opened?
-    end
+    # Other adapters should include it for the base methods used 
+    # by the {Yell::Logger}.
+    module Base
+
+      # The main method for calling the adapter.
+      #
+      # Adapter classes should provide their own implementation 
+      # of this method.
+      def write( level, message )
+        nil
+      end
+
+      # Determine whether to write at the given severity.
+      #
+      # @example
+      #   write? :error
+      #
+      # @param [String,Symbol,Integer] severity The severity to ask if to write or not.
+      #
+      # @return [Boolean] true or false
+      def write?( severity )
+        @level.nil? || @level.at?( severity )
+      end
+
+      # Close the adapter (stream, connection, etc).
+      #
+      # Adapter classes should provide their own implementation 
+      # of this method.
+      def close
+        nil
+      end
+
+      # Set the log level.
+      #
+      # @example Set minimum level to :info
+      #   level :info
+      #
+      # For more examples, refer to {Yell::Level}.
+      def level( severity = nil )
+        @level = Yell::Level.new( severity )
+      end
 
-    # Closes the file handle or connection (in case of a database adapter)
-    def close
-      close! unless closed?
-    end
-
-
-    private
-
-    def reset?; closed?; end
-
-    # stub
-    def open!
-      raise "Not implemented"
-    end
-
-    def opened?; false; end
-
-    # stub
-    def close!
-      raise "Not implemented"
-    end
-
-    def closed?; !opened?; end
-
-    # stub
-    def write
-      raise 'Not implemented'
     end
 
   end
 end
+

data/lib/yell/adapters/datefile.rb

@@ -1,38 +1,63 @@
-module Yell::Adapters
-  class Datefile < Yell::Adapters::File
+# encoding: utf-8
 
-    DefaultDatePattern = "%Y%m%d"
+module Yell #:nodoc:
+  module Adapters #:nodoc:
 
-    def initialize ( options = {}, &block )
-      @date_pattern = options[:date_pattern] || DefaultDatePattern
-      @date = nil # default; do not override --R
+    # The +Datefile+ adapter is similar to the +File+ adapter. However, it
+    # rotates the file at midnight.
+    class Datefile < Yell::Adapters::File
 
-      @file_basename = options[:filename] || default_filename
-      options[:filename] = @file_basename
+      # The default date pattern, e.g. "19820114" (14 Jan 1982)
+      DefaultDatePattern = "%Y%m%d"
 
-      super( options, &block )
-    end
+      def initialize( options = {}, &block )
+        @date_pattern = options[:date_pattern] || DefaultDatePattern
 
-    def reset!( now )
-      @filename = new_filename
-      super( now )
-    end
+        @file_basename = options[:filename] || default_filename
+        options[:filename] = @file_basename
 
+        @date = nil # default; do not override --R
+
+        super( options, &block )
+      end
 
-    private
+      def write( level, message )
+        close if close?
 
-    def reset?
-      _date = Time.now.strftime( @date_pattern )
-      unless opened? && _date == @date
-        @date = _date
-        return true
+        super( level, message )
       end
 
-      false
-    end
+      # @override Reset the file handle
+      def close
+        @filename = new_filename
+
+        super
+      end
+
+
+      private
+
+      # Determines whether to close the file handle or not.
+      #
+      # It is based on the `:date_pattern` (can be passed as option upon initialize). 
+      # If the current time hits the pattern, it closes the file stream.
+      #
+      # @return [Boolean] true or false
+      def close?
+        _date = Time.now.strftime( @date_pattern )
+        if !@stream or _date != @date
+          @date = _date
+          return true
+        end
+
+        false
+      end
+
+      # Sets the filename with the `:date_pattern` appended to it.
+      def new_filename
+        @file_basename.sub( /(\.\w+)?$/, ".#{@date}\\1" )
+      end
 
-    def new_filename
-      @file_basename.sub( /(\.\w+)?$/, ".#{@date}\\1" )
     end
 
   end

data/lib/yell/adapters/file.rb

@@ -1,95 +1,32 @@
-module Yell::Adapters
-  class File < Yell::Adapters::Base
+# encoding: utf-8
 
-    Colors = {
-      'DEBUG'   => "\e[32;1m",  # green;bold
-#        'INFO'    => "\e[0m",     # white
-      'WARN'    => "\e[33;1m",  # yello;bold
-      'ERROR'   => "\e[31;1m",  # red;bold
-      'FATAL'   => "\e[35;1m",  # magenta;bold
-      'UNKNOWN' => "\e[36m",    # cyan
-      'DEFAULT' => "\e[0m"      # NONE
-    }
+module Yell #:nodoc:
+  module Adapters #:nodoc:
 
-    def initialize ( options = {}, &block )
-      super
+    # The +File+ adapter is the most basic. As one would expect, it's used 
+    # for logging into files.
+    class File < Yell::Adapters::Io
 
-      @formatter = formatter_from( options )
+      def initialize( options = {}, &block )
+        super( nil, options, &block )
 
-      @colorize = options[:colorize]
-      @filename = options[:filename] || default_filename
-
-      @file_prefix, @file_suffix = options[:file_prefix], options[:file_suffix]
-
-      # validate the filename
-      unless @filename.is_a?( String )
-        raise( TypeError, "Argument :filename must be a string." )
+        @filename = options.fetch(:filename, default_filename)
       end
-    end
-
-    def call ( level, msg )
-      super # Base call
-
-      msg = @formatter.format( @level, message )
-      msg = colorize( @level, msg ) if @colorize
-      msg << "\n" unless msg[-1] == ?\n # add new line if there is none
 
-      write( msg )
-    end
-
-
-    private
-
-    def write ( msg )
-      @file.print( msg )
-      @file.flush
-    rescue Exception => e
-      close # make sure the file gets closed
-      raise( e ) # re-raise the error
-    end
-
-    def close!
-      @file.close
-      @file = nil
-    end
-
-    def open!
-      # create directory if not exists
-      dirname = ::File.dirname( @filename )
-      FileUtils.mkdir_p( dirname ) unless ::File.directory?( dirname )
+      # @override Lazily open the file handle
+      def stream
+        @stream ||= ::File.open( @filename, ::File::WRONLY|::File::APPEND|::File::CREAT )
+      end
 
-      # open file for appending if exists, or create a new
-      filename = [ dirname, "#{@file_prefix}#{::File.basename(@filename)}#{@file_suffix}" ].join( '/' )
-      @file = ::File.open( filename, ::File::WRONLY|::File::APPEND|::File::CREAT )
-    end
 
-    def opened?; !@file.nil?; end
+      private
 
-    # Returns the right formatter from the given options
-    def formatter_from( options )
-      if options.key?(:formatter)
-        # this is done, so we can set :formatter => false to just output the given message
-        options[:formatter] || Yell::Formatter.new( "%m" )
-      elsif options[:formatter]
-        # the options :formatter was given
-        Yell::Formatter.new(
-          options[:formatter][:pattern],
-          options[:formatter][:date_pattern]
-        )
-      else
-        # Standard formatter
-        Yell::Formatter.new
+      def default_filename
+        ::File.directory?("log") ? "log/#{Yell.env}.log" : "#{Yell.env}.log"
       end
-    end
-
-    def colorize( level, msg )
-      return msg unless color = Colors[level.upcase]
-      color + msg + Colors['DEFAULT']
-    end
 
-    def default_filename
-      "#{Yell.config.env}.log"
     end
 
   end
 end
+

data/lib/yell/adapters/io.rb

@@ -0,0 +1,89 @@
+module Yell
+  module Adapters
+
+    class Io
+      include Yell::Adapters::Base
+
+      # The possible unix log colors
+      Colors = {
+        'DEBUG'   => "\e[32;1m",  # green;bold
+        # 'INFO'    => "\e[0m",     # white
+        'WARN'    => "\e[33;1m",  # yello;bold
+        'ERROR'   => "\e[31;1m",  # red;bold
+        'FATAL'   => "\e[35;1m",  # magenta;bold
+        'UNKNOWN' => "\e[36m",    # cyan
+        'DEFAULT' => "\e[0m"      # NONE
+      }
+
+      # Accessor to the io stream
+      attr_reader :stream
+
+
+      def initialize( stream, options = {}, &block )
+        @stream   = stream
+        @options  = options
+
+        level options.fetch(:level, nil)
+        format options.fetch(:format, nil)
+        colorize! options.fetch(:colorize, false)
+
+        instance_eval &block if block
+      end
+
+      # Main method to calling the file adapter.
+      #
+      # The method formats the message and writes it to the file handle.
+      #
+      # @example
+      #   write( 'info', 'Hello World' )
+      def write( level, message )
+        msg = @formatter.format( level, message )
+
+        # colorize if applicable
+        if colorize? and color = Colors[level]
+          msg = color + msg + Colors['DEFAULT']
+        end
+
+        msg << "\n" unless msg[-1] == ?\n # add new line if there is none
+
+        write!( msg )
+      end
+
+      # Set the format for your message.
+      def format( pattern, date_pattern = nil )
+        @formatter = case pattern
+          when Yell::Formatter then pattern
+          when false then Yell::Formatter.new( "%m" )
+          else Yell::Formatter.new( pattern, date_pattern )
+        end
+      end
+
+      # Enable colorizing the log output.
+      def colorize!( color = true )
+        @colorize = color
+      end
+
+      # Determie whether to colorize the log output or nor
+      #
+      # @return [Boolean] true or false
+      def colorize?; !!@colorize; end
+
+
+      private
+
+      # TODO: Implement Buffer to not flush immediately.
+      def write!( message )
+        stream.print( message )
+        stream.flush
+      rescue => e
+        close
+
+        # re-raise the exception
+        raise( e, caller )
+      end
+
+    end
+
+  end
+end
+

data/lib/yell/formatter.rb

@@ -1,37 +1,39 @@
-module Yell
+# encoding: utf-8
+
+module Yell #:nodoc:
+
+  # The +Formatter+ provides a handle to configure your log message style.
   class Formatter
 
     PatternTable = {
-      "m" => "message", 
+      "m" => "message",
       "d" => "date",
-      "l" => "level.downcase",
+      "l" => "level[0]",
       "L" => "level.upcase",
-      "p" => "$$", # pid
+      "p" => "$$",
       "h" => "hostname"
     }
     PatternRegexp = /([^%]*)(%\d*)?([dlLphm])?(.*)/
-    
     DefaultPattern = "%d [%5L] %p %h: %m"
-    DefaultDatePattern = "%Y-%m-%d %H:%M:%S" # ISO8601
-
-    
-    def initialize ( pattern = nil, date_pattern = nil )
-      @pattern = pattern || DefaultPattern
-      @date_pattern = date_pattern || DefaultDatePattern
-      
-      define_format_method
+
+
+    def initialize( pattern = nil, date_pattern = nil )
+      @pattern      = pattern || DefaultPattern
+      @date_pattern = date_pattern
+
+      define!
     end
-    
+
 
     private
 
-    def define_format_method
+    def define!
       buff, args, _pattern = "", [], @pattern.dup
-      
+
       while true
         match = PatternRegexp.match( _pattern )
 
-        buff << match[1] unless match[1].empty? 
+        buff << match[1] unless match[1].empty?
         break if match[2].nil?
 
         buff << match[2] + 's' # '%s'
@@ -41,18 +43,21 @@ module Yell
       end
 
       instance_eval %-
-        def format ( level, message )
+        def format( level, message )
           sprintf( "#{buff}", #{args.join(',')} )
         end
       -
     end
 
-    def date; Time.now.strftime( @date_pattern ); end
-    
+    def date
+      @date_pattern ? Time.now.strftime( @date_pattern ) : Time.now.iso8601
+    end
+
     def hostname
       return @hostname if defined?( @hostname )
       @hostname = Socket.gethostname rescue nil
     end
 
   end
-end
+end
+

data/lib/yell/level.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+module Yell #:nodoc:
+
+  # The +Level+ class handles the severities for you in order to determine 
+  # if an adapter should log or not.
+  #
+  # In order to setup your level, you have certain modifiers available:
+  #   at :warn    # will be set to :warn level only
+  #   gt :warn    # Will set from :error level onwards
+  #   gte :warn   # Will set from :warn level onwards
+  #   lt :warn    # Will set from :info level an below
+  #   lte :warn   # Will set from :warn level and below
+  #
+  #
+  # You are able to combine those modifiers to your convenience.
+  #
+  # @example Set from :info to :error (including)
+  #   Yell::Level.new(:info).lte(:error)
+  #
+  # @example Set from :info to :error (excluding)
+  #   Yell::Level.new(:info).lt(:error)
+  #
+  # @example Set at :info only
+  #   Yell::Level.new.at(:info)
+  class Level
+
+    # Create a new level instance.
+    #
+    # @example Enable all severities
+    #   Yell::Level.new
+    #
+    # @example Pass the minimum possible severity
+    #   Yell::Level.new :warn
+    #
+    # @example Pass an array to exactly set the level at the given severities
+    #   Yell::Level.new [:info, :error]
+    #
+    # @example Pass a range to set the level within the severities
+    #   Yell::Level.new (:info..:error)
+    #
+    # @param [Integer,String,Symbol,Array,Range,nil] severity The severity for the level.
+    def initialize( severity = nil )
+      @severities = Yell::Severities.map { true } # all levels allowed by default
+
+      case severity
+        when Array then severity.each { |s| at(s) }
+        when Range then gte(severity.first).lte(severity.last)
+        when Integer, String, Symbol then gte(severity)
+      end
+    end
+
+    # Returns whether the level is allowed at the given severity
+    #
+    # @example
+    #   at? :warn
+    #   at? 0       # debug
+    def at?( severity )
+      index = index_from( severity )
+
+      index.nil? ? false : @severities[index]
+    end
+
+    def at( severity ) #:nodoc:
+      calculate! :==, severity
+      self
+    end
+
+    def gt( severity ) #:nodoc:
+      calculate! :>, severity
+      self
+    end
+
+    def gte( severity ) #:nodoc:
+      calculate! :>=, severity
+      self
+    end
+
+    def lt( severity ) #:nodoc:
+      calculate! :<, severity
+      self
+    end
+
+    def lte( severity ) #:nodoc:
+      calculate! :<=, severity
+      self
+    end
+
+
+    private
+
+    def calculate!( modifier, severity )
+      index = index_from( severity )
+      return if index.nil?
+
+      case modifier
+        when :>   then ascending!( index+1 )
+        when :>=  then ascending!( index )
+        when :<   then descending!( index-1 )
+        when :<=  then descending!( index )
+        else set!( index ) # :==
+      end
+
+      taint unless tainted?
+    end
+
+    def index_from( severity )
+      case severity
+        when Integer        then severity
+        when String, Symbol then Yell::Severities.index( severity.to_s.upcase )
+        else nil
+      end
+    end
+
+    def ascending!( index )
+      @severities.each_with_index do |s, i|
+        next if s == false # skip
+
+        @severities[i] = i < index ? false : true
+      end
+    end
+
+    def descending!( index )
+      @severities.each_with_index do |s, i|
+        next if s == false # skip
+
+        @severities[i] = index < i ? false : true
+      end
+    end
+
+    def set!( index )
+      @severities.map! { false } unless tainted?
+
+      @severities[index] = true
+    end
+
+  end
+
+end

data/lib/yell/logger.rb

@@ -1,82 +1,145 @@
-module Yell
-  class Logger
-    Levels = [ 'debug', 'info', 'warn', 'error', 'fatal', 'unknown' ]
+# encoding: utf-8
 
+module Yell #:nodoc:
 
+  # The +Logger+ is your entrypoint. Anything onwards is derived from here.
+  class Logger
+    # Creates a new Logger instance
+    #
+    # @example A standard file logger
+    #   Yell::Logger.new
+    #   Yell::Logger.new 'development.log'
+    #
+    # @example A standard datefile logger
+    #   Yell::Logger.new :datefile
+    #   Yell::Logger.new :datefile, 'development.log'
+    #
+    # @example Setting the log level
+    #   Yell::Logger.new :level => :warn
+    #
+    #   Yell::Logger.new do
+    #     level :warn
+    #   end
+    #
+    # @example Combined settings
+    #   Yell::Logger.new 'development.log', :level => :warn
+    #
+    #   Yell::Logger.new :datefile, 'development.log' do
+    #     level :info
+    #   end
     def initialize( *args, &block )
       @adapters = []
 
       # extract options
       @options = args.last.is_a?(Hash) ? args.pop : {}
 
+      # set the log level when given
+      # level @options[:level] if @options[:level]
+      level @options[:level] # default
+
       # check if filename was given as argument and put it into the @options
       if args.last.is_a?( String )
         @options[:filename] = args.pop unless @options[:filename]
       end
 
-      @default_adapter = args.last.is_a?( Symbol ) ? args.pop : :file
+      # extract adapter
+      adapter args.pop if args.any?
 
-      # eval the given block if any
-      instance_eval( &block ) if block
+      # set the log level when given
+      level @options[:level] if @options[:level]
 
-      build
-    end
+      # eval the given block
+      instance_eval &block if block
 
-    # === the following methods are used for the logger setup
-    def adapter ( type, options = {}, &block )
-      @adapters << Yell::Adapters.new( type, @options.merge(options), &block )
-    rescue LoadError => e
-      raise Yell::NoSuchAdapter, e.message
+      define!
     end
 
-    def level ( val )
-      @level = case val
-        when Integer then val
-        when String, Symbol then Levels.index( val.to_s )
-        else nil
+    # Define an adapter to be used for logging.
+    #
+    # @example Standard adapter
+    #   adapter :file
+    #
+    # @example Standard adapter with filename
+    #   adapter :file, 'development.log'
+    #
+    #   # Alternative notation for filename in options
+    #   adapter :file, :filename => 'developent.log'
+    #
+    # @example Standard adapter with filename and additional options
+    #   adapter :file, 'development.log', :level => :warn
+    #
+    # @example Set the adapter directly from an adapter instance
+    #   adapter( Yell::Adapter::File.new )
+    #
+    # @param [Symbol] type The type of the adapter, may be `:file` or `:datefile` (default `:file`)
+    #
+    # @return A new +Yell::Adapter+ 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| 
+        h.merge( c.is_a?(String) ? {:filename => c} : c  )
       end
+
+      @adapters << Yell::Adapters[ type, options, &block ]
+    rescue NameError => e
+      raise Yell::NoSuchAdapter, type
+    end
+
+    # Set the minimum log level.
+    #
+    # @example Set the level to :warn
+    #   level :warn
+    #
+    # @param [String, Symbol, Integer] val The minimum log level
+    def level( val = nil )
+      @level = Yell::Level.new( val )
     end
 
     # Convenience method for resetting all adapters of the Logger.
     #
-    # @param [true, false] now Perform the reset immediately? (default false)
-    def reset!( now = false )
-      close
-      open if now
+    # @param [Boolean] now Perform the reset immediately (default false)
+    def close( now = false )
+      @adapters.each(&:close)
     end
 
-    def close; @adapters.each(&:close); end
-    def open; @adapters.each(&:open); end
 
-    
     private
 
-    def build
-      adapter @default_adapter if @adapters.empty? # default adapter when none defined
+    # Sets a default adapter if none was given explicitly and defines the log methods on
+    # the logger instance.
+    def define!
+      adapter :file if @adapters.empty? # default adapter when none defined
 
-      define_log_methods
+      define_log_methods!
     end
 
-    def define_log_methods
-      Levels.each_with_index do |name, index|
-        instance_eval %-
-          def #{name}?; #{@level.nil? || index >= @level}; end
-
-          def #{name} ( data = '' )
-            return unless #{name}?
+    # Creates instance methods for every defined log level (debug, info, ...) depending
+    # on whether anything should be logged upon, for instance, #info.
+    def define_log_methods!
+      Yell::Severities.each do |l|
+        name = l.downcase
 
-            data = yield if block_given?
-            process( "#{name}", data )
-
-            data
-          end
+        instance_eval %-
+          def #{name}?; #{@level.at?(name)}; end  # def info?; true; end
+                                                  #
+          def #{name}( message = nil )            # def info( message = nil )
+            return unless #{name}?                #   return unless info?
+                                                  #
+            message = yield if block_given?       #   message = yield if block_given?
+            write( "#{l}", message )              #   write( "INFO", message )
+                                                  #
+            true                                  #   true
+          end                                     # end
         -
       end
     end
 
-    def process ( level, data )
-      @adapters.each { |a| a.call( level, data ) }
+    # Cycles all the adapters and writes the message
+    def write( level, message )
+      @adapters.each { |a| a.write(level, message) if a.write?(level) }
     end
 
   end
 end
+

data/lib/yell/version.rb

@@ -1,4 +1,4 @@
 module Yell
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 
 end

data/spec/spec_helper.rb

@@ -7,14 +7,5 @@ require 'rspec'
 require 'timecop'
 
 RSpec.configure do |config|
-
-  config.before do
-    Yell.config.stub!( :yaml_file ).and_return( File.dirname(__FILE__) + '/config/yell.yml' )
-  end
-
-  config.after do
-    Yell.config.reload! # to not run into caching problems during tests
-  end
-
 end
 

data/spec/yell_spec.rb

@@ -15,3 +15,4 @@ describe Yell do
   end
 
 end
+

data/yell.gemspec

@@ -9,10 +9,10 @@ Gem::Specification.new do |s|
   s.authors     = ["Rudolf Schmidt"]
   
   s.homepage    = "http://rubygems.org/gems/yell"
-  s.summary     = %q{Logging library to log into files and databases}
-  s.description = %q{Logging library to log into files and databases}
+  s.summary     = %q{Yell - Your Extensible Logging Library }
+  s.description = %q{An easy to use logging library to log into files and any other self-defined adapters}
 
-  s.rubyforge_project = "d_log"
+  s.rubyforge_project = "yell"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yell
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-23 00:00:00.000000000Z
+date: 2012-03-17 00:00:00.000000000 Z
 dependencies: []
-description: Logging library to log into files and databases
+description: An easy to use logging library to log into files and any other self-defined
+  adapters
 email: 
 executables: []
 extensions: []
@@ -19,15 +20,19 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- LICENSE.txt
+- README.md
 - Rakefile
 - init.rb
 - lib/yell.rb
 - lib/yell/adapters.rb
+- lib/yell/adapters/.file.rb.swp
 - lib/yell/adapters/base.rb
 - lib/yell/adapters/datefile.rb
 - lib/yell/adapters/file.rb
-- lib/yell/config.rb
+- lib/yell/adapters/io.rb
 - lib/yell/formatter.rb
+- lib/yell/level.rb
 - lib/yell/logger.rb
 - lib/yell/version.rb
 - spec/spec.opts
@@ -53,9 +58,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: d_log
-rubygems_version: 1.8.10
+rubyforge_project: yell
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
-summary: Logging library to log into files and databases
-test_files: []
+summary: Yell - Your Extensible Logging Library
+test_files:
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/yell_spec.rb

data/lib/yell/config.rb

@@ -1,53 +0,0 @@
-module Yell
-  class Config
-  
-    def initialize( yaml_file = nil )
-      @yaml_file = yaml_file
-      
-      reload!
-    end
-    
-    def reload!; @options = nil; end
-    
-    def []( key ); options[key]; end
-    
-    def options
-      @options ||= begin
-        if yaml_file_defined?
-          require 'yaml'
-          require 'erb'
-
-          (YAML.load( ERB.new( File.read( yaml_file ) ).result ) || {})[ env ] || {}
-        else
-          {} # default
-        end
-      end
-    end
-
-    def env
-      ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'default'
-    end
-
-    def root
-      return ENV['RAILS_ROOT'] if ENV['RAILS_ROOT']
-      return RAILS_ROOT if defined?( RAILS_ROOT )
-
-      '.'
-    end
-    
-
-    private
-
-    def yaml_file_defined?
-      yaml_file && File.exist?( yaml_file )
-    end
-    
-    # Locates the yell.yml file. The file can end in .yml or .yaml,
-    # and be located in the current directory (eg. project root) or
-    # in a .config/ or config/ subdirectory of the current directory.
-    def yaml_file
-      @yaml_file || Dir.glob( "#{root}/{,.config/,config/}yell{.yml,.yaml}" ).first
-    end
-   
-  end   
-end