redcar 0.3.1dev → 0.3.2dev

data/lib/logging/lib/logging/appenders/console.rb

@@ -1,60 +0,0 @@
-
-module Logging::Appenders
-
-  # This class provides an Appender that can write to STDOUT.
-  #
-  class Stdout < ::Logging::Appenders::IO
-
-    # call-seq:
-    #    Stdout.new( name = 'stdout' )
-    #    Stdout.new( :layout => layout )
-    #    Stdout.new( name = 'stdout', :level => 'info' )
-    #
-    # Creates a new Stdout Appender. The name 'stdout' will be used unless
-    # another is given. Optionally, a layout can be given for the appender
-    # to use (otherwise a basic appender will be created) and a log level
-    # can be specified.
-    #
-    # Options:
-    #
-    #    :layout   => the layout to use when formatting log events
-    #    :level    => the level at which to log
-    #
-    def initialize( *args )
-      opts = Hash === args.last ? args.pop : {}
-      name = args.empty? ? 'stdout' : args.shift 
-
-      super(name, STDOUT, opts)
-    end
-  end  # class Stdout
-
-  # This class provides an Appender that can write to STDERR.
-  #
-  class Stderr < ::Logging::Appenders::IO
-
-    # call-seq:
-    #    Stderr.new( name = 'stderr' )
-    #    Stderr.new( :layout => layout )
-    #    Stderr.new( name = 'stderr', :level => 'warn' )
-    #
-    # Creates a new Stderr Appender. The name 'stderr' will be used unless
-    # another is given. Optionally, a layout can be given for the appender
-    # to use (otherwise a basic appender will be created) and a log level
-    # can be specified.
-    #
-    # Options:
-    #
-    #    :layout   => the layout to use when formatting log events
-    #    :level    => the level at which to log
-    #
-    def initialize( *args )
-      opts = Hash === args.last ? args.pop : {}
-      name = args.empty? ? 'stderr' : args.shift 
-
-      super(name, STDERR, opts)
-    end
-  end  # class Stderr
-
-end  # module Logging::Appenders
-
-# EOF

data/lib/logging/lib/logging/appenders/email.rb

@@ -1,75 +0,0 @@
-# 
-# require 'net/smtp'
-# require 'time' # get rfc822 time format
-# 
-# # a replacement EmailOutputter.  This is essentially the default EmailOutptter from Log4r but with the following
-# # changes:
-# #   1) if there is data to send in an email, then do not send anything
-# #   2) connect to the smtp server at the last minute, do not connect at startup and then send later on.
-# #   3) Fix the To: field so that it looks alright.
-# module Logging::Appenders
-# 
-# class Email < ::Logging::Appender
-#   include Buffering
-# 
-#   attr_reader :server, :port, :domain, :acct, :authtype, :subject
-# 
-#   # TODO: make the from/to fields modifiable
-#   #       possibly the subject, too
-# 
-#   def initialize( name, opts = {} )
-#     super(name, opts)
-# 
-#     af = opts.getopt(:buffsize) ||
-#          opts.getopt(:buffer_size) ||
-#          100
-#     configure_buffering({:auto_flushing => af}.merge(opts))
-# 
-#     # get the SMTP parameters
-#     @from = opts.getopt(:from)
-#     raise ArgumentError, 'Must specify from address' if @from.nil?
-# 
-#     @to = opts.getopt(:to, '').split(',')
-#     raise ArgumentError, 'Must specify recipients' if @to.empty?
-# 
-#     @server   = opts.getopt :server, 'localhost'
-#     @port     = opts.getopt :port, 25, :as => Integer
-#     @domain   = opts.getopt(:domain, ENV['HOSTNAME']) || 'localhost.localdomain'
-#     @acct     = opts.getopt :acct
-#     @passwd   = opts.getopt :passwd
-#     @authtype = opts.getopt :authtype, :cram_md5, :as => Symbol
-#     @subject  = opts.getopt :subject, "Message of #{$0}"
-#     @params   = [@server, @port, @domain, @acct, @passwd, @authtype]
-#   end
-#   
-#   # call-seq:
-#   #    flush
-#   #
-#   # Create and send an email containing the current message buffer.
-#   #
-#   def flush
-#     return self if buffer.empty?
-# 
-#     ### build a mail header for RFC 822
-#     rfc822msg =  "From: #{@from}\n"
-#     rfc822msg << "To: #{@to.join(",")}\n"
-#     rfc822msg << "Subject: #{@subject}\n"
-#     rfc822msg << "Date: #{Time.new.rfc822}\n"
-#     rfc822msg << "Message-Id: <#{"%.8f" % Time.now.to_f}@#{@domain}>\n\n"
-#     rfc822msg << buffer.join
-# 
-#     ### send email
-#     Net::SMTP.start(*@params) {|smtp| smtp.sendmail(rfc822msg, @from, @to)}
-#     self
-#   rescue StandardError, TimeoutError => err
-#     self.level = :off
-#     ::Logging.log_internal {'e-mail notifications have been disabled'}
-#     ::Logging.log_internal(-2) {err}
-#   ensure
-#     buffer.clear
-#   end
-# 
-# end   # class Email
-# end   # module Logging::Appenders
-# 
-# # EOF

data/lib/logging/lib/logging/appenders/file.rb

@@ -1,58 +0,0 @@
-
-module Logging::Appenders
-
-  # This class provides an Appender that can write to a File.
-  #
-  class File < ::Logging::Appenders::IO
-
-    # call-seq:
-    #    File.assert_valid_logfile( filename )    => true
-    #
-    # Asserts that the given _filename_ can be used as a log file by ensuring
-    # that if the file exists it is a regular file and it is writable. If
-    # the file does not exist, then the directory is checked to see if it is
-    # writable.
-    #
-    # An +ArgumentError+ is raised if any of these assertions fail.
-    #
-    def self.assert_valid_logfile( fn )
-      if ::File.exist?(fn)
-        if not ::File.file?(fn)
-          raise ArgumentError, "#{fn} is not a regular file"
-        elsif not ::File.writable?(fn)
-          raise ArgumentError, "#{fn} is not writeable"
-        end
-      elsif not ::File.writable?(::File.dirname(fn))
-        raise ArgumentError, "#{::File.dirname(fn)} is not writable"
-      end
-      true
-    end
-
-    # call-seq:
-    #    File.new( name, :filename => 'file' )
-    #    File.new( name, :filename => 'file', :truncate => true )
-    #    File.new( name, :filename => 'file', :layout => layout )
-    #
-    # Creates a new File Appender that will use the given filename as the
-    # logging destination. If the file does not already exist it will be
-    # created. If the :truncate option is set to +true+ then the file will
-    # be truncated before writing begins; otherwise, log messages will be
-    # appened to the file.
-    #
-    def initialize( name, opts = {} )
-      @fn = opts.getopt(:filename, name)
-      raise ArgumentError, 'no filename was given' if @fn.nil?
-      self.class.assert_valid_logfile(@fn)
-      mode = opts.getopt(:truncate) ? 'w' : 'a'
-
-      super(name, ::File.new(@fn, mode), opts)
-    end
-
-    # Returns the path to the logfile.
-    #
-    def filename() @fn.dup end
-
-  end  # class FileAppender
-end  # module Logging::Appenders
-
-# EOF

data/lib/logging/lib/logging/appenders/growl.rb

@@ -1,197 +0,0 @@
-
-module Logging::Appenders
-
-  # 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 maping 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 assciated 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
-
-      Thread.pass
-    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
-        Thread.stop
-        loop do
-          sleep 0.5
-          @c_mutex.synchronize {
-            call_growl(*@c_queue.shift) until @c_queue.empty?
-          }
-          Thread.stop if @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  # class Growl
-end  # module Logging::Appenders
-
-# EOF

data/lib/logging/lib/logging/appenders/io.rb

@@ -1,69 +0,0 @@
-
-module Logging::Appenders
-
-  # This class provides an Appender that can write to any IO stream
-  # configured for writing.
-  #
-  class IO < ::Logging::Appender
-    include Buffering
-
-    # call-seq:
-    #    IO.new( name, io )
-    #    IO.new( name, io, :layout => layout )
-    #
-    # Creates a new IO Appender using the given name that will use the _io_
-    # stream as the logging destination.
-    #
-    def initialize( name, io, opts = {} )
-      unless io.respond_to? :write
-        raise TypeError, "expecting an IO object but got '#{io.class.name}'"
-      end
-
-      @io = io
-      @io.sync = true if @io.respond_to?(:sync) rescue nil
-
-      configure_buffering(opts)
-      super(name, opts)
-    end
-
-    # call-seq:
-    #    close( footer = true )
-    #
-    # Close the appender and writes the layout footer to the logging
-    # destination if the _footer_ flag is set to +true+. Log events will
-    # no longer be written to the logging destination after the appender
-    # is closed.
-    #
-    def close( *args )
-      return self if @io.nil?
-      super
-      io, @io = @io, nil
-      io.close unless [STDIN, STDERR, STDOUT].include?(io)
-    rescue IOError => err
-    ensure
-      return self
-    end
-
-    # call-seq:
-    #    flush
-    #
-    # Call +flush+ to force an appender to write out any buffered log events.
-    # Similar to IO#flush, so use in a similar fashion.
-    #
-    def flush
-      return self if @io.nil?
-      @io.write(buffer.join) unless buffer.empty?
-      @io.flush
-      self
-    rescue StandardError => err
-      self.level = :off
-      ::Logging.log_internal {"appender #{name.inspect} has been disabled"}
-      ::Logging.log_internal(-2) {err}
-    ensure
-      buffer.clear
-    end
-
-  end  # class IO
-end  # module Logging::Appenders
-
-# EOF