yell 1.3.0 → 1.4.0

data/lib/yell/helpers/silencer.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Yell #:nodoc:
+  module Helpers #:nodoc:
+    module Silencer
+
+      # Set the silence pattern
+      def silence( *patterns )
+        silencer.add(*patterns)
+      end
+
+      # @private
+      def silencer
+        @silencer
+      end
+
+
+      private
+
+      def reset!
+        @silencer = Yell::Silencer.new
+
+        super
+      end
+
+      def silence!( *messages )
+        silencer.silence!(*messages) if silencer.silence?
+      end
+
+    end
+  end
+end
+

data/lib/yell/helpers/tracer.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+module Yell #:nodoc:
+  module Helpers #:nodoc:
+    module Tracer #:nodoc:
+
+      # 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 )
+        case severity
+        when false then @tracer.set("gt.#{Yell::Severities.last}")
+        else @tracer.set(severity)
+        end
+      end
+
+      # @private
+      def trace
+        @tracer
+      end
+
+
+      private
+
+      def reset!
+        @tracer = Yell::Level.new
+
+        super
+      end
+
+      def inspectables
+        [:trace] | super
+      end
+
+    end
+  end
+end
+

data/lib/yell/level.rb

@@ -23,28 +23,9 @@ module Yell #:nodoc:
   # @example Set at :info only
   #   Yell::Level.new.at(:info)
   class Level
-    module Helpers
-      # Accessor to the log level
-      attr_reader :level
-
-      # Set the minimum log level.
-      #
-      # @example Set the level to :warn
-      #   level = :warn
-      #
-      # @param [String, Symbol, Integer] severity The minimum log level
-      def level=( severity )
-        @level = case severity
-          when Yell::Level then severity
-          else Yell::Level.new( severity )
-        end
-      end
-    end
 
     InterpretRegexp = /(at|gt|gte|lt|lte)?\.?(#{Yell::Severities.join('|')})/i
 
-    attr_reader :severities
-
     # Create a new level instance.
     #
     # @example Enable all severities
@@ -60,8 +41,22 @@ module Yell #:nodoc:
     #   Yell::Level.new (:info..:error)
     #
     # @param [Integer,String,Symbol,Array,Range,nil] severity The severity for the level.
-    def initialize( severity = nil )
-      reset!( severity )
+    def initialize( *severities )
+      set( *severities )
+    end
+
+    # Set the severity to the given format
+    def set( *severities )
+      @severities = Yell::Severities.map { true }
+      severity = severities.length > 1 ? severities : severities.first
+
+      case severity
+      when Array then at( *severity )
+      when Range then gte( severity.first ).lte( severity.last )
+      when Integer, Symbol then gte( severity )
+      when String then interpret( severity )
+      when Yell::Level then @severities = severity.severities
+      end
     end
 
     # Returns whether the level is allowed at the given severity
@@ -77,7 +72,7 @@ module Yell #:nodoc:
       index.nil? ? false : @severities[index]
     end
 
-    # Set the level at specific severities.
+    # Set the level at specific severities
     #
     # @example Set at :debug and :error only
     #   at :debug, :error
@@ -140,29 +135,25 @@ module Yell #:nodoc:
 
     # 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]
-        r
-      end
-
-      "#<#{self.class.name} severities: #{severities * ', '}>"
+      inspectables = Yell::Severities.select.with_index { |l, i| !!@severities[i] }
+      "#<#{self.class.name} severities: #{inspectables * ', '}>"
     end
 
+    # @private
+    def severities
+      @severities
+    end
 
-    private
+    # @private
+    def ==(other)
+      return super unless other.respond_to?(:severities)
+      severities == other.severities
+    end
 
-    def reset!( severity )
-      @severities = Yell::Severities.map { true }
 
-      case severity
-        when Array then at( *severity )
-        when Range then gte( severity.first ).lte( severity.last )
-        when Integer, Symbol then gte( severity )
-        when String then interpret!( severity )
-      end
-    end
+    private
 
-    def interpret!( severities )
+    def interpret( severities )
       severities.split( ' ' ).each do |severity|
         if m = InterpretRegexp.match(severity)
           m[1].nil? ? __send__( :gte, m[2] ) : __send__( m[1], m[2] )
@@ -175,11 +166,11 @@ module Yell #:nodoc:
       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 ) # :==
+      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?
@@ -187,9 +178,9 @@ module Yell #:nodoc:
 
     def index_from( severity )
       case severity
-        when Integer        then severity
-        when String, Symbol then Yell::Severities.index( severity.to_s.upcase )
-        else nil
+      when Integer        then severity
+      when String, Symbol then Yell::Severities.index( severity.to_s.upcase )
+      else nil
       end
     end
 

data/lib/yell/logger.rb

@@ -2,6 +2,32 @@
 
 require 'pathname'
 
+# TODO: DSL improvements
+#
+# Initlalize an empty logger
+#   logger = Yell.new(adapters: false)
+#   logger.adapters.add :stdout
+#
+# Or shorthand for adapters.add
+#   logger.add :stdout
+#
+# Or with a block
+#   logger = Yell.new do |l|
+#     l.add :stdout
+#     l.add :stderr
+#   end
+#
+#  logger = Yell.new do |l|
+#    l.adapters.add :stdout
+#    l.adapters.add :stderr
+#  end
+#
+#
+# Define Silencers
+#   logger = Yell.new do |l|
+#     l.silence /password/
+#   end
+#
 module Yell #:nodoc:
 
   # The +Yell::Logger+ is your entrypoint. Anything onwards is derived from here.
@@ -9,14 +35,16 @@ module Yell #:nodoc:
   # A +Yell::Logger+ instance holds all your adapters and sends the log events 
   # to them if applicable. There are multiple ways of how to create a new logger.
   class Logger
-    include Yell::Level::Helpers
+    include Yell::Helpers::Base
+    include Yell::Helpers::Level
+    include Yell::Helpers::Formatter
+    include Yell::Helpers::Adapters
+    include Yell::Helpers::Tracer
+    include Yell::Helpers::Silencer
 
     # The name of the logger instance
     attr_reader :name
 
-    # Stacktrace or not
-    attr_reader :trace
-
     # Initialize a new Logger
     #
     # @example A standard file logger
@@ -40,7 +68,7 @@ module Yell #:nodoc:
     #     l.level = :info
     #   end
     def initialize( *args, &block )
-      @adapters = []
+      reset!
 
       # extract options
       @options = args.last.is_a?(Hash) ? args.pop : {}
@@ -57,6 +85,9 @@ module Yell #:nodoc:
       self.name = @options.fetch(:name, nil) # no name by default
       self.trace = @options.fetch(:trace, :error) # trace from :error level onwards
 
+      # silencer
+      self.silence(*@options[:silence])
+
       # extract adapter
       self.adapter(args.pop) if args.any?
 
@@ -64,7 +95,7 @@ module Yell #:nodoc:
       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
 
 
@@ -79,57 +110,6 @@ module Yell #:nodoc:
       @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.
-    #
-    # @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 [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 )
-    end
-
     # Creates instance methods for every log level:
     #   `debug` and `debug?`
     #   `info` and `info?`
@@ -140,21 +120,25 @@ 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(self, #{index}, *m, &b) #   write Yell::Event.new(self, 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?
+                                                          #
+          m = silencer.silence(*m) if silencer.silence?   #   m = silencer.silence(*m) if silencer.silence?
+          return false if m.empty?                        #   return false if m.empty?
+                                                          #
+          event = Yell::Event.new(self, #{index}, *m, &b) #   event = Yell::Event.new(self, 1, *m, &b)
+          write(event)                                    #   write(event)
+          true                                            #   true
+        end                                               # end
       EOS
     end
 
     # Get a pretty string representation of the logger.
     def inspect
-      inspection = inspectables.inject( [] ) { |r, c| r << "#{c}: #{send(c).inspect}" }
-      "#<#{self.class.name} #{inspection * ', '}, adapters: #{@adapters.map(&:inspect) * ', '}>"
+      inspection = inspectables.map { |m| "#{m}: #{send(m).inspect}" }
+      "#<#{self.class.name} #{inspection * ', '}, adapters: #{adapters.map(&:inspect) * ', '}>"
     end
 
     # @private
@@ -162,10 +146,6 @@ module Yell #:nodoc:
       @adapters.each(&:close)
     end
 
-    # @private
-    def adapters
-      @adapters
-    end
 
     private
 
@@ -188,12 +168,12 @@ module Yell #:nodoc:
 
     # Cycles all the adapters and writes the message
     def write( event )
-      @adapters.each { |a| a.write(event) }
+      adapters.each { |a| a.write(event) }
     end
 
     # Get an array of inspected attributes for the adapter.
     def inspectables
-      [ :name, :level, :trace ]
+      [:name] | super
     end
 
   end

data/lib/yell/repository.rb

@@ -13,43 +13,45 @@ module Yell #:nodoc:
     extend MonitorMixin
     include Singleton
 
-    attr_accessor :loggers
-
     def initialize
       @loggers = {}
     end
 
-    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
+    # 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 []( name )
-        synchronize { instance.fetch(name) or raise Yell::LoggerNotFound.new(name) }
-      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 { instance.fetch(name) or raise Yell::LoggerNotFound.new(name) }
+    end
 
-      # Get the list of all loggers in the repository
-      #
-      # @return [Hash] The map of loggers
-      def loggers
-        synchronize { instance.loggers }
-      end
+    # Get the list of all loggers in the repository
+    #
+    # @return [Hash] The map of loggers
+    def self.loggers
+      synchronize { instance.loggers }
     end
 
+    # @private
+    def loggers
+      @loggers
+    end
 
+    # @private
+    #
     # Fetch the logger by the given name.
     #
     # If the logger could not be found and has a superclass, it 
@@ -59,7 +61,7 @@ module Yell #:nodoc:
       logger = loggers[name] || loggers[name.to_s]
 
       if logger.nil? && name.respond_to?(:superclass)
-        return fetch( name.superclass )
+        return fetch(name.superclass)
       end
 
       logger