yell 1.4.0 → 2.2.2

data/lib/yell/adapters/file.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Yell #:nodoc:
   module Adapters #:nodoc:
 
@@ -11,14 +9,14 @@ module Yell #:nodoc:
 
       # @overload setup!( options )
       def setup!( options )
-        @filename = ::File.expand_path options.fetch(:filename, default_filename)
+        @filename = ::File.expand_path(Yell.__fetch__(options, :filename, default: default_filename))
 
         super
       end
 
       # @overload open!
       def open!
-        @stream = ::File.open( @filename, ::File::WRONLY|::File::APPEND|::File::CREAT )
+        @stream = ::File.open(@filename, ::File::WRONLY|::File::APPEND|::File::CREAT)
 
         super
       end
@@ -26,13 +24,11 @@ module Yell #:nodoc:
       def default_filename #:nodoc:
         logdir = ::File.expand_path("log")
 
-        ::File.expand_path ::File.directory?(logdir) ? "#{logdir}/#{Yell.env}.log" : "#{Yell.env}.log"
+        ::File.expand_path(::File.directory?(logdir) ? "#{logdir}/#{Yell.env}.log" : "#{Yell.env}.log")
       end
 
     end
 
-    register( :file, Yell::Adapters::File )
-
   end
 end
 

data/lib/yell/adapters/io.rb

@@ -1,8 +1,5 @@
-# encoding: utf-8
-
 module Yell #:nodoc:
   module Adapters #:nodoc:
-
     class Io < Yell::Adapters::Base
       include Yell::Helpers::Formatter
 
@@ -45,39 +42,38 @@ module Yell #:nodoc:
       def setup!( options )
         @stream = nil
 
-        self.colors = options.fetch(:colors, false)
-        self.format = options.fetch(:format, nil)
-        self.sync = options.fetch(:sync, true)
+        self.colors = Yell.__fetch__(options, :colors, default: false)
+        self.formatter = Yell.__fetch__(options, :format, :formatter)
+        self.sync = Yell.__fetch__(options, :sync, default: true)
 
         super
       end
 
       # @overload write!( event )
       def write!( event )
-        message = format.format(event)
+        message = formatter.call(event)
 
         # colorize if applicable
         if colors and color = TTYColors[event.level]
           message = color + message + TTYColors[-1]
         end
 
-        message << "\n" unless message[-1] == ?\n
-        stream.syswrite( message )
+        stream.syswrite(message)
 
         super
       end
 
       # @overload open!
       def open!
-        @stream.sync = self.sync if @stream.respond_to? :sync
-        @stream.flush            if @stream.respond_to? :flush
+        @stream.sync = self.sync if @stream.respond_to?(:sync)
+        @stream.flush if @stream.respond_to?(:flush)
 
         super
       end
 
       # @overload close!
       def close!
-        @stream.close if @stream.respond_to? :close
+        @stream.close if @stream.respond_to?(:close)
         @stream = nil
 
         super
@@ -93,11 +89,9 @@ module Yell #:nodoc:
 
       # @overload inspectables
       def inspectables
-        super.concat [:format, :colors, :sync]
+        super.concat [:formatter, :colors, :sync]
       end
-
     end
-
   end
 end
 

data/lib/yell/adapters/streams.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Yell #:nodoc:
   module Adapters #:nodoc:
 
@@ -27,9 +25,6 @@ module Yell #:nodoc:
 
     end
 
-    register( :stdout, Yell::Adapters::Stdout )
-    register( :stderr, Yell::Adapters::Stderr )
-
   end
 end
 

data/lib/yell/adapters.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
 module Yell #:nodoc:
-
   # AdapterNotFound is raised whenever you want to instantiate an 
   # adapter that does not exist.
   class AdapterNotFound < StandardError; end
@@ -9,6 +7,41 @@ module Yell #:nodoc:
   # the logger. You should not have to call the corresponding classes
   # directly.
   module Adapters
+    class Collection
+      def initialize( options = {} )
+        @options = options
+        @collection = []
+      end
+
+      def add( type = :file, *args, &block )
+        options = [@options, *args].inject(Hash.new) do |h, c|
+          h.merge( [String, Pathname].include?(c.class) ? {:filename => c} : c  )
+        end
+
+        # remove possible :null adapters
+        @collection.shift if @collection.first.instance_of?(Yell::Adapters::Base)
+
+        new_adapter = Yell::Adapters.new(type, options, &block)
+        @collection.push(new_adapter)
+
+        new_adapter
+      end
+
+      def empty?
+        @collection.empty?
+      end
+
+      # @private
+      def write( event )
+        @collection.each { |c| c.write(event) }
+        true
+      end
+
+      # @private
+      def close
+        @collection.each { |c| c.close }
+      end
+    end
 
     # holds the list of known adapters
     @adapters = {}
@@ -18,27 +51,25 @@ module Yell #:nodoc:
     # @example
     #   Yell::Adapters.register( :myadapter, MyAdapter )
     def self.register( name, klass )
-      @adapters[name] = klass
+      @adapters[name.to_sym] = klass
     end
 
     # Returns an instance of the given processor type.
     #
     # @example A simple file adapter
     #   Yell::Adapters.new( :file )
-    def self.new( name, options = {}, &block )
-      return name if name.is_a?(Yell::Adapters::Base)
+    def self.new( type, options = {}, &block )
+      return type if type.is_a?(Yell::Adapters::Base)
 
-      adapter = case name
+      adapter = case type
       when STDOUT then @adapters[:stdout]
       when STDERR then @adapters[:stderr]
-      else @adapters[name]
+      else @adapters[type.to_sym]
       end
 
-      raise AdapterNotFound.new(name) if adapter.nil?
-
+      raise AdapterNotFound.new(type) if adapter.nil?
       adapter.new(options, &block)
     end
-
   end
 end
 

data/lib/yell/configuration.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'erb'
 require 'yaml'
 
@@ -13,8 +11,8 @@ module Yell #:nodoc:
       yaml = YAML.load( ERB.new(File.read(file)).result )
 
       # in case we have ActiveSupport
-      if yaml.respond_to?(:with_indifference_access)
-        yaml = yaml.with_indifferent_access
+      if defined?(ActiveSupport::HashWithIndifferentAccess)
+        yaml = ActiveSupport::HashWithIndifferentAccess.new(yaml)
       end
 
       yaml[Yell.env] || {}

data/lib/yell/event.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'time'
 require 'socket'
 
@@ -14,6 +12,26 @@ module Yell #:nodoc:
     # jruby and rubinius seem to have a different caller
     CallerIndex = defined?(RUBY_ENGINE) && ["rbx", "jruby"].include?(RUBY_ENGINE) ? 1 : 2
 
+
+    class Options
+      include Comparable
+
+      attr_reader :severity
+      attr_reader :caller_offset
+
+      def initialize( severity, caller_offset )
+        @severity = severity
+        @caller_offset = caller_offset
+      end
+
+      def <=>( other )
+        @severity <=> other
+      end
+
+      alias :to_i :severity
+      alias :to_int :severity
+    end
+
     # Prefetch those values (no need to do that on every new instance)
     @@hostname  = Socket.gethostname rescue nil
     @@progname  = $0
@@ -21,23 +39,27 @@ module Yell #:nodoc:
     # Accessor to the log level
     attr_reader :level
 
-    # Accessor to the log messages
+    # Accessor to the log message
     attr_reader :messages
 
     # Accessor to the time the log event occured
     attr_reader :time
 
+    # Accessor to the logger's name
+    attr_reader :name
+
+
+    def initialize( logger, options, *messages)
+      @time = Time.now
+      @name = logger.name
 
-    def initialize(logger, level, *messages, &block)
-      @time     = Time.now
-      @level    = level
+      extract!(options)
 
       @messages = messages
-      @messages << block.call if block
 
-      @caller = logger.trace.at?(level) ? caller[CallerIndex].to_s : ''
-      @file   = nil
-      @line   = nil
+      @caller = logger.trace.at?(level) ? caller[caller_index].to_s : ''
+      @file = nil
+      @line = nil
       @method = nil
 
       @pid = nil
@@ -81,6 +103,20 @@ module Yell #:nodoc:
 
     private
 
+    def extract!( options )
+      if options.is_a?(Yell::Event::Options)
+        @level = options.severity
+        @caller_offset = options.caller_offset
+      else
+        @level = options
+        @caller_offset = 0
+      end
+    end
+
+    def caller_index
+      CallerIndex + @caller_offset
+    end
+
     def backtrace!
       if m = CallerRegexp.match(@caller)
         @file, @line, @method = m[1..-1]

data/lib/yell/formatter.rb

@@ -1,12 +1,19 @@
-# encoding: utf-8
 require 'time'
 
+# TODO: Register custom formats
+#
+# @example The Yell default fomat
+#   Yell::Formatter.register(:default)
+#
+# @example The Ruby standard logger format
+#   Yell::Formatter.register(:stdlogger, "%l, [%d #%p] %5L -- : %m", "%Y-%m-%dT%H:%M:%S.%6N")
+#
 module Yell #:nodoc:
 
   # No format on the log message
   #
   # @example
-  #   logger = Yell.new STDOUT, :format => false
+  #   logger = Yell.new STDOUT, format: false
   #   logger.info "Hello World!"
   #   #=> "Hello World!"
   NoFormat = "%m"
@@ -14,7 +21,7 @@ module Yell #:nodoc:
   # Default Format
   #
   # @example
-  #   logger = Yell.new STDOUT, :format => Yell::DefaultFormat
+  #   logger = Yell.new STDOUT, format: Yell::DefaultFormat
   #   logger.info "Hello World!"
   #   #=> "2012-02-29T09:30:00+01:00 [ INFO] 65784 : Hello World!"
   #   #    ^                         ^       ^       ^
@@ -24,7 +31,7 @@ module Yell #:nodoc:
   # Basic Format
   #
   # @example
-  #   logger = Yell.new STDOUT, :format => Yell::BasicFormat
+  #   logger = Yell.new STDOUT, format: Yell::BasicFormat
   #   logger.info "Hello World!"
   #   #=> "I, 2012-02-29T09:30:00+01:00 : Hello World!"
   #   #    ^  ^                          ^
@@ -35,7 +42,7 @@ module Yell #:nodoc:
   # Extended Format
   #
   # @example
-  #   logger = Yell.new STDOUT, :format => Yell::ExtendedFormat
+  #   logger = Yell.new STDOUT, format: Yell::ExtendedFormat
   #   logger.info "Hello World!"
   #   #=> "2012-02-29T09:30:00+01:00 [ INFO] 65784 localhost : Hello World!"
   #   #    ^                          ^      ^     ^           ^
@@ -47,8 +54,8 @@ module Yell #:nodoc:
   class Formatter
 
     Table = {
-      "m" => "message(*event.messages)",   # Message
-      "l" => "level(event.level)[0,1]",    # Level (short), e.g.'I', 'W'
+      "m" => "message(event.messages)",    # Message
+      "l" => "level(event.level, 1)",      # Level (short), e.g.'I', 'W'
       "L" => "level(event.level)",         # Level, e.g. 'INFO', 'WARN'
       "d" => "date(event.time)",           # ISO8601 Timestamp
       "h" => "event.hostname",             # Hostname
@@ -58,23 +65,54 @@ module Yell #:nodoc:
       "F" => "event.file",                 # Path with filename where the logger was called
       "f" => "File.basename(event.file)",  # Filename where the loger was called
       "M" => "event.method",               # Method name where the logger was called
-      "n" => "event.line"                  # Line where the logger was called
+      "n" => "event.line",                 # Line where the logger was called
+      "N" => "event.name"                  # Name of the logger
     }
 
-    Matcher = /([^%]*)(%\d*)?(#{Table.keys.join('|')})?(.*)/
+    # For standard formatted backwards compatibility
+    LegacyTable = Hash[ Table.keys.map { |k| [k, 'noop'] } ].merge(
+      'm' => 'message(msg)',
+      'l' => 'level(event, 1)',
+      'L' => 'level(event)',
+      'd' => 'date(time)',
+      "p" => "$$",
+      'P' => 'progname'
+    )
+
+    PatternMatcher = /([^%]*)(%\d*)?(#{Table.keys.join('|')})?(.*)/m
+
+
+    attr_reader :pattern, :date_pattern
 
 
     # Initializes a new +Yell::Formatter+.
     #
-    # Upon initialization it defines a format method. `format` takes 
-    # a {Yell::Event} instance as agument in order to apply for desired log 
+    # Upon initialization it defines a format method. `format` takes
+    # a {Yell::Event} instance as agument in order to apply for desired log
     # message formatting.
-    def initialize( pattern = nil, date_pattern = nil )
-      @pattern      = pattern || Yell::DefaultFormat
-      @date_pattern = date_pattern || :iso8601
+    #
+    # @example Blank formatter
+    #   Formatter.new
+    #
+    # @example Formatter with a message pattern
+    #   Formatter.new("%d [%5L] %p : %m")
+    #
+    # @example Formatter with a message and date pattern
+    #   Formatter.new("%d [%5L] %p : %m", "%D %H:%M:%S.%L")
+    #
+    # @example Formatter with a message modifier
+    #   Formatter.new do |f|
+    #     f.modify(Hash) { |h| "Hash: #{h.inspect}" }
+    #   end
+    def initialize( *args, &block )
+      builder = Builder.new(*args, &block)
+
+      @pattern = builder.pattern
+      @date_pattern = builder.date_pattern
+      @modifier = builder.modifier
 
       define_date_method!
-      define_format_method!
+      define_call_method!
     end
 
     # Get a pretty string
@@ -85,75 +123,117 @@ module Yell #:nodoc:
 
     private
 
+    # Message modifier class to allow different modifiers for different requirements.
+    class Modifier
+      def initialize
+        @repository = {}
+      end
+
+      def set( key, &block )
+        @repository.merge!(key => block)
+      end
+
+      def call( message )
+        case
+        when mod = @repository[message.class] || @repository[message.class.to_s]
+          mod.call(message)
+        when message.is_a?(Array)
+          message.map { |m| call(m) }.join(" ")
+        when message.is_a?(Hash)
+          message.map { |k, v| "#{k}: #{v}" }.join(", ")
+        when message.is_a?(Exception)
+          backtrace = message.backtrace ? "\n\t#{message.backtrace.join("\n\t")}" : ""
+          sprintf("%s: %s%s", message.class, message.message, backtrace)
+        else
+          message
+        end
+      end
+    end
+
+    # Builder class to allow setters that won't be accessible once
+    # transferred to the Formatter
+    class Builder
+      attr_accessor :pattern, :date_pattern
+      attr_reader :modifier
+
+      def initialize( pattern = nil, date_pattern = nil, &block )
+        @modifier = Modifier.new
+
+        @pattern = case pattern
+        when false then Yell::NoFormat
+        when nil then Yell::DefaultFormat
+        else pattern
+        end.dup
+
+        @pattern << "\n" unless @pattern[-1] == ?\n # add newline if not present
+        @date_pattern = date_pattern || :iso8601
+
+        block.call(self) if block
+      end
+
+      def modify( key, &block )
+        modifier.set(key, &block)
+      end
+    end
+
     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)"
+      else t.iso8601
       end
 
-      instance_eval %-
-        def date( t )
+      # define the method
+      instance_eval <<-METHOD, __FILE__, __LINE__
+        def date(t = Time.now)
           #{buf}
         end
-      -
+       METHOD
+    end
+
+    # define a standard +Logger+ backwards compatible #call method for the formatter
+    def define_call_method!
+      instance_eval <<-METHOD, __FILE__, __LINE__
+        def call(event, time = nil, progname = nil, msg = nil)
+          event.is_a?(Yell::Event) ? #{to_sprintf(Table)} : #{to_sprintf(LegacyTable)}
+        end
+      METHOD
     end
 
-    def define_format_method!
+    def to_sprintf( table )
       buff, args, _pattern = "", [], @pattern.dup
 
       while true
-        match = Matcher.match(_pattern)
+        match = PatternMatcher.match(_pattern)
 
         buff << match[1] unless match[1].empty?
         break if match[2].nil?
 
         buff << match[2] + 's'
-        args << Table[ match[3] ]
+        args << table[ match[3] ]
 
         _pattern = match[4]
       end
 
-      instance_eval <<-EOS, __FILE__, __LINE__
-        def format( event )
-          sprintf("#{buff}", #{args.join(',')})
-        end
-      EOS
+      %Q{sprintf("#{buff.gsub(/"/, '\"')}", #{args.join(', ')})}
     end
 
-    # The iso8601 implementation of the standard Time library is more than
-    # twice as slow compared to using strftime. So, we just implement
-    # it ourselves --R
-    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))
+    def level( sev, length = nil )
+      severity = case sev
+      when Integer then Yell::Severities[sev] || 'ANY'
+      else sev
       end
 
-      t.strftime("%Y-%m-%dT%H:%M:%S#{zone}")
-    end
-
-    def level( l )
-      Yell::Severities[ l ]
+      length.nil? ? severity : severity[0, length]
     end
 
-    def message( *messages )
-      messages.map { |m| to_message(m) }.join(" ")
+    def message( messages )
+      @modifier.call(messages.is_a?(Array) && messages.size == 1 ? messages.first : messages)
     end
 
-    def to_message( m )
-      case m
-      when Hash
-        m.map { |k,v| "#{k}: #{v}" }.join( ", " )
-      when Exception
-        backtrace = m.backtrace ? "\n\t#{m.backtrace.join("\n\t")}" : ""
-        sprintf("%s: %s%s", m.class, m.message, backtrace)
-      else
-        m
-      end
+    # do nothing
+    def noop
+      ''
     end
 
   end

data/lib/yell/helpers/{adapters.rb → adapter.rb}

@@ -1,8 +1,6 @@
-# encoding: utf-8
 module Yell #:nodoc:
   module Helpers #:nodoc:
-    module Adapters #:nodoc:
-
+    module Adapter #:nodoc:
       # Define an adapter to be used for logging.
       #
       # @example Standard adapter
@@ -12,40 +10,32 @@ module Yell #:nodoc:
       #   adapter :file, 'development.log'
       #
       #   # Alternative notation for filename in options
-      #   adapter :file, :filename => 'developent.log'
+      #   adapter :file, filename: 'developent.log'
       #
       # @example Standard adapter with filename and additional options
-      #   adapter :file, 'development.log', :level => :warn
+      #   adapter :file, 'development.log', level: :warn
       #
       # @example Set the adapter directly from an adapter instance
-      #   adapter( Yell::Adapter::File.new )
+      #   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|
-          h.merge( [String, Pathname].include?(c.class) ? {:filename => c} : c  )
-        end
-
-        @adapters << Yell::Adapters.new(type, options, &block)
+        adapters.add(type, *args, &block)
       end
 
-      # @private
       def adapters
-        @adapters
+        @__adapters__
       end
 
-
       private
 
       def reset!
-        @adapters = []
+        @__adapters__ = Yell::Adapters::Collection.new(@options)
 
         super
       end
-
     end
   end
 end
-

data/lib/yell/helpers/base.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 module Yell #:nodoc:
   module Helpers #:nodoc:
     module Base #:nodoc:

data/lib/yell/helpers/formatter.rb

@@ -1,26 +1,26 @@
-# encoding: utf-8
 module Yell #:nodoc:
   module Helpers #:nodoc:
     module Formatter #:nodoc:
 
       # Set the format for your message.
-      def format=( pattern )
-        @formatter = case pattern
+      def formatter=( pattern )
+        @__formatter__ = case pattern
         when Yell::Formatter then pattern
-        when false then Yell::Formatter.new(Yell::NoFormat)
         else Yell::Formatter.new(*pattern)
         end
       end
+      alias :format= :formatter=
 
-      # @private
-      def format
-        @formatter
+      def formatter
+        @__formatter__
       end
+      alias :format :formatter
+
 
       private
 
       def reset!
-        @formatter = Yell::Formatter.new
+        @__formatter__ = Yell::Formatter.new
 
         super
       end