logging 1.8.2 → 2.0.0

data/lib/logging/appenders/growl.rb

@@ -1,200 +0,0 @@
-
-module Logging::Appenders
-
-  # Accessor / Factory for the Growl appender.
-  #
-  def self.growl( *args )
-    return ::Logging::Appenders::Growl if args.empty?
-    ::Logging::Appenders::Growl.new(*args)
-  end
-
-  # This class provides an Appender that can send notifications to the Growl
-  # notification system on Mac OS X.
-  #
-  # +growlnotify+ must be installed somewhere in the path in order for the
-  # appender to function properly.
-  #
-  class Growl < ::Logging::Appender
-
-    # :stopdoc:
-    ColoredRegexp = %r/\e\[([34][0-7]|[0-9])m/
-    # :startdoc:
-
-    # call-seq:
-    #    Growl.new( name, opts = {} )
-    #
-    # Create an appender that will log messages to the Growl framework on a
-    # Mac OS X machine.
-    #
-    def initialize( name, opts = {} )
-      super
-
-      @growl = "growlnotify -w -n \"#{@name}\" -t \"%s\" -m \"%s\" -p %d &"
-
-      @coalesce = opts.getopt(:coalesce, false)
-      @title_sep = opts.getopt(:separator)
-
-      # provides a mapping from the default Logging levels
-      # to the Growl notification levels
-      @map = [-2, -1, 0, 1, 2]
-
-      map = opts.getopt(:map)
-      self.map = map unless map.nil?
-      setup_coalescing if @coalesce
-
-      # make sure the growlnotify command can be called
-      unless system('growlnotify -v >> /dev/null 2>&1')
-        self.level = :off
-        ::Logging.log_internal {'growl notifications have been disabled'}
-      end
-    end
-
-    # call-seq:
-    #    map = { logging_levels => growl_levels }
-    #
-    # Configure the mapping from the Logging levels to the Growl
-    # notification levels. This is needed in order to log events at the
-    # proper Growl level.
-    #
-    # Without any configuration, the following mapping will be used:
-    #
-    #    :debug  =>  -2
-    #    :info   =>  -1
-    #    :warn   =>  0
-    #    :error  =>  1
-    #    :fatal  =>  2
-    #
-    def map=( levels )
-      map = []
-      levels.keys.each do |lvl|
-        num = ::Logging.level_num(lvl)
-        map[num] = growl_level_num(levels[lvl])
-      end
-      @map = map
-    end
-
-
-  private
-
-    # call-seq:
-    #    write( event )
-    #
-    # Write the given _event_ to the growl notification facility. The log
-    # event will be processed through the Layout associated with this
-    # appender. The message will be logged at the level specified by the
-    # event.
-    #
-    def write( event )
-      title = ''
-      priority = 0
-      message = if event.instance_of?(::Logging::LogEvent)
-          priority = @map[event.level]
-          @layout.format(event)
-        else
-          event.to_s
-        end
-      return if message.empty?
-
-      message = message.gsub(ColoredRegexp, '')
-      if @title_sep
-        title, message = message.split(@title_sep)
-        title, message = '', title if message.nil?
-      end
-
-      growl(title.strip, message.strip, priority)
-      self
-    end
-
-    # call-seq:
-    #    growl_level_num( level )    => integer
-    #
-    # Takes the given _level_ as a string or integer and returns the
-    # corresponding Growl notification level number.
-    #
-    def growl_level_num( level )
-      level = Integer(level)
-      if level < -2 or level > 2
-        raise ArgumentError, "level '#{level}' is not in range -2..2"
-      end
-      level
-    end
-
-    # call-seq:
-    #    growl( title, message, priority )
-    #
-    # Send the _message_ to the growl notifier using the given _title_ and
-    # _priority_.
-    #
-    def growl( title, message, priority )
-      message.tr!("`", "'")
-      if @coalesce then coalesce(title, message, priority)
-      else call_growl(title, message, priority) end
-    end
-
-    # call-seq:
-    #    coalesce( title, message, priority )
-    #
-    # Attempt to coalesce the given _message_ with any that might be pending
-    # in the queue to send to the growl notifier. Messages are coalesced
-    # with any in the queue that have the same _title_ and _priority_.
-    #
-    # There can be only one message in the queue, so if the _title_ and/or
-    # _priority_ don't match, the message in the queue is sent immediately
-    # to the growl notifier, and the current _message_ is queued.
-    #
-    def coalesce( *msg )
-      @c_mutex.synchronize do
-        if @c_queue.empty?
-          @c_queue << msg
-          @c_thread.run
-
-        else
-          qmsg = @c_queue.last
-          if qmsg.first != msg.first or qmsg.last != msg.last
-            @c_queue << msg
-          else
-            qmsg[1] << "\n" << msg[1]
-          end
-        end
-      end
-    end
-
-    # call-seq:
-    #    setup_coalescing
-    #
-    # Setup the appender to handle coalescing of messages before sending
-    # them to the growl notifier. This requires the creation of a thread and
-    # mutex for passing messages from the appender thread to the growl
-    # notifier thread.
-    #
-    def setup_coalescing
-      @c_mutex = Mutex.new
-      @c_queue = []
-
-      @c_thread = Thread.new do
-        loop do
-          Thread.stop if @c_queue.empty?
-          sleep 1
-          @c_mutex.synchronize {
-            call_growl(*@c_queue.shift) until @c_queue.empty?
-          }
-        end  # loop
-      end  # Thread.new
-    end
-
-    # call-seq:
-    #    call_growl( title, message, priority )
-    #
-    # Call the growlnotify application with the given parameters. If the
-    # system call fails, the growl appender will be disabled.
-    #
-    def call_growl( *args )
-      unless system(@growl % args)
-        self.level = :off
-        ::Logging.log_internal {'growl notifications have been disabled'}
-      end
-    end
-
-  end  # Growl
-end  # Logging::Appenders
-

data/lib/logging/config/configurator.rb

@@ -1,187 +0,0 @@
-
-module Logging::Config
-
-  # The Configurator class is used to configure the Logging framework
-  # using information found in a block of Ruby code. This block is evaluated
-  # in the context of the configurator's DSL.
-  #
-  class Configurator
-
-    class Error < StandardError; end  # :nodoc:
-
-    # call-seq:
-    #    Configurator.process( &block )
-    #
-    def self.process( &block )
-      new.load(&block)
-    end
-
-    # call-seq:
-    #    load { block }
-    #
-    # Loads the configuration from the _block_ and configures the Logging
-    # gem.
-    #
-    def load( &block )
-      raise Error, "missing configuration block" unless block
-
-      dsl = TopLevelDSL.new
-      dsl.instance_eval(&block)
-
-      pre_config dsl.__pre_config
-      ::Logging::Logger[:root]  # ensures the log levels are defined
-      appenders  dsl.__appenders
-      loggers    dsl.__loggers
-    end
-
-    # call-seq:
-    #    pre_config( config )
-    #
-    # Configures the logging levels, object format style, and root logging
-    # level.
-    #
-    def pre_config( config )
-      if config.nil?
-        ::Logging.init unless ::Logging.initialized?
-        return
-      end
-
-      # define levels
-      levels = config[:levels]
-      ::Logging.init(levels) unless levels.nil?
-
-      # format as
-      format = config[:format_as]
-      ::Logging.format_as(format) unless format.nil?
-
-      # backtrace
-      value = config[:backtrace]
-      ::Logging.backtrace(value) unless value.nil?
-    end
-
-    # call-seq:
-    #    appenders( ary )
-    #
-    # Given an array of Appender configurations, this method will iterate
-    # over each and create the Appender(s).
-    #
-    def appenders( ary )
-      ary.each {|name, config| appender(name, config)}
-    end
-
-    # call-seq:
-    #    loggers( ary )
-    #
-    # Given an array of Logger configurations, this method will iterate over
-    # each and create the Logger(s).
-    #
-    def loggers( ary )
-      ary.each do |name, config|
-        l = Logging::Logger[name]
-        l.level     = config[:level] if config[:level]
-        l.additive  = config[:additive] if l.respond_to? :additive=
-        l.trace     = config[:trace]
-        l.appenders = Array(config[:appenders]).
-                            map {|nm| ::Logging::Appenders[nm]}
-      end
-    end
-
-    # call-seq:
-    #    appender( name, config )
-    #
-    # Creates a new Appender based on the given _config_ options (a hash).
-    # The type of Appender created is determined by the 'type' option in the
-    # config. The remaining config options are passed to the Appender
-    # initializer.
-    #
-    # The config options can also contain a 'layout' option. This should be
-    # another set of options used to create a Layout for this Appender.
-    #
-    def appender( name, config )
-      type = config.delete(:type)
-      raise Error, "appender type not given for #{name.inspect}" if type.nil?
-
-      config[:layout] = layout(config[:layout]) if config.has_key? :layout
-
-      clazz = ::Logging::Appenders.const_get type
-      clazz.new(name, config)
-    rescue NameError
-      raise Error, "unknown appender class Logging::Appenders::#{type}"
-    end
-
-    # call-seq:
-    #    layout( config )
-    #
-    # Creates a new Layout based on the given _config_ options (a hash).
-    # The type of Layout created is determined by the 'type' option in the
-    # config. The remaining config options are passed to the Layout
-    # initializer.
-    #
-    def layout( config )
-      return ::Logging::Layouts::Basic.new if config.nil?
-
-      type = config.delete(:type)
-      raise Error, 'layout type not given' if type.nil?
-
-      clazz = ::Logging::Layouts.const_get type
-      clazz.new config
-    rescue NameError
-      raise Error, "unknown layout class Logging::Layouts::#{type}"
-    end
-
-    class DSL
-      instance_methods.each do |m|
-        undef_method m unless m[%r/^(__|object_id|instance_eval)/]
-      end
-
-      def self.process( &block )
-        dsl = new
-        dsl.instance_eval(&block)
-        dsl.__hash
-      end
-
-      def __hash
-        @hash ||= Hash.new
-      end
-
-      def method_missing( method, *args, &block )
-        args << DSL.process(&block) if block
-
-        key = method.to_sym
-        value = (1 == args.length ? args.first : args)
-        __store(key, value)
-      end
-
-      def __store( key, value )
-        __hash[key] = value
-      end
-    end
-
-    class TopLevelDSL < DSL
-      undef_method :method_missing
-
-      def initialize
-        @loggers = []
-        @appenders = []
-      end
-
-      def pre_config( &block )
-        __store(:preconfig, DSL.process(&block))
-      end
-
-      def logger( name, &block )
-        @loggers << [name, DSL.process(&block)]
-      end
-
-      def appender( name, &block )
-        @appenders << [name, DSL.process(&block)]
-      end
-
-      def __pre_config() __hash[:preconfig]; end
-      def __loggers() @loggers; end
-      def __appenders() @appenders; end
-    end
-
-  end  # class Configurator
-end  # module Logging::Config
-

data/lib/logging/config/yaml_configurator.rb

@@ -1,190 +0,0 @@
-
-module Logging::Config
-
-  # The YamlConfigurator class is used to configure the Logging framework
-  # using information found in a YAML file.
-  #
-  class YamlConfigurator
-
-    class Error < StandardError; end  # :nodoc:
-
-    class << self
-
-      # call-seq:
-      #    YamlConfigurator.load( file, key = 'logging_config' )
-      #
-      # Load the given YAML _file_ and use it to configure the Logging
-      # framework. The file can be either a filename, and open File, or an
-      # IO object. If it is the latter two, the File / IO object will not be
-      # closed by this method.
-      #
-      # The configuration will be loaded from the given _key_ in the YAML
-      # stream.
-      #
-      def load( file, key = 'logging_config' )
-        io, close = nil, false
-        case file
-        when String
-          io = File.open(file, 'r')
-          close = true
-        when IO
-          io = file
-        else
-          raise Error, 'expecting a filename or a File'
-        end
-
-        begin
-          new(io, key).load
-        ensure
-          io.close if close
-        end
-        nil
-      end
-    end  # class << self
-
-    # call-seq:
-    #    YamlConfigurator.new( io, key )
-    #
-    # Creates a new YAML configurator that will load the Logging
-    # configuration from the given _io_ stream. The configuration will be
-    # loaded from the given _key_ in the YAML stream.
-    #
-    def initialize( io, key  )
-      YAML.load_documents(io) do |doc|
-        @config = doc[key]
-        break if @config.instance_of?(Hash)
-      end
-
-      unless @config.instance_of?(Hash)
-        raise Error, "Key '#{key}' not defined in YAML configuration"
-      end
-    end
-
-    # call-seq:
-    #    load
-    #
-    # Loads the Logging configuration from the data loaded from the YAML
-    # file.
-    #
-    def load
-      pre_config @config['pre_config']
-      ::Logging::Logger[:root]  # ensures the log levels are defined
-      appenders @config['appenders']
-      loggers @config['loggers']
-    end
-
-    # call-seq:
-    #    pre_config( config )
-    #
-    # Configures the logging levels, object format style, and root logging
-    # level.
-    #
-    def pre_config( config )
-      # if no pre_config section was given, just create an empty hash
-      # we do this to ensure that some logging levels are always defined
-      config ||= Hash.new
-
-      # define levels
-      levels = config['define_levels']
-      ::Logging.init(levels) unless levels.nil?
-
-      # format as
-      format = config['format_as']
-      ::Logging.format_as(format) unless format.nil?
-
-      # backtrace
-      value = config['backtrace']
-      ::Logging.backtrace(value) unless value.nil?
-
-      # grab the root logger and set the logging level
-      root = ::Logging::Logger.root
-      if config.has_key?('root')
-        root.level = config['root']['level']
-      end
-    end
-
-    # call-seq:
-    #    appenders( ary )
-    #
-    # Given an array of Appender configurations, this method will iterate
-    # over each and create the Appender(s).
-    #
-    def appenders( ary )
-      return if ary.nil?
-
-      ary.each {|h| appender(h)}
-    end
-
-    # call-seq:
-    #    loggers( ary )
-    #
-    # Given an array of Logger configurations, this method will iterate over
-    # each and create the Logger(s).
-    #
-    def loggers( ary )
-      return if ary.nil?
-
-      ary.each do |config|
-        name = config['name']
-        raise Error, 'Logger name not given' if name.nil?
-
-        l = Logging::Logger.new name
-        l.level = config['level'] if config.has_key?('level')
-        l.additive = config['additive'] if l.respond_to? :additive=
-        l.trace = config['trace'] if l.respond_to? :trace=
-
-        if config.has_key?('appenders')
-          l.appenders = config['appenders'].map {|n| ::Logging::Appenders[n]}
-        end
-      end
-    end
-
-    # call-seq:
-    #    appender( config )
-    #
-    # Creates a new Appender based on the given _config_ options (a hash).
-    # The type of Appender created is determined by the 'type' option in the
-    # config. The remaining config options are passed to the Appender
-    # initializer.
-    #
-    # The config options can also contain a 'layout' option. This should be
-    # another set of options used to create a Layout for this Appender.
-    #
-    def appender( config )
-      return if config.nil?
-      config = config.dup
-
-      type = config.delete('type')
-      raise Error, 'Appender type not given' if type.nil?
-
-      name = config.delete('name')
-      raise Error, 'Appender name not given' if name.nil?
-
-      config['layout'] = layout(config.delete('layout'))
-
-      clazz = ::Logging::Appenders.const_get type
-      clazz.new(name, config)
-    end
-
-    # call-seq:
-    #    layout( config )
-    #
-    # Creates a new Layout based on the given _config_ options (a hash).
-    # The type of Layout created is determined by the 'type' option in the
-    # config. The remaining config options are passed to the Layout
-    # initializer.
-    #
-    def layout( config )
-      return if config.nil?
-      config = config.dup
-
-      type = config.delete('type')
-      raise Error, 'Layout type not given' if type.nil?
-
-      clazz = ::Logging::Layouts.const_get type
-      clazz.new config
-    end
-
-  end  # class YamlConfigurator
-end  # module Logging::Config
-