redcar 0.3.1dev → 0.3.2dev

data/lib/logging/lib/logging/utils.rb

@@ -1,153 +0,0 @@
-
-# --------------------------------------------------------------------------
-class Hash
-
-  # call-seq:
-  #    getopt( key, default = nil, :as => class )
-  #
-  # Returns the value associated with the _key_. If the has does not contain
-  # the _key_, then the _default_ value is returned.
-  #
-  # Optionally, the value can be converted into to an instance of the given
-  # _class_. The supported classes are:
-  #
-  #     Integer
-  #     Float
-  #     Array
-  #     String
-  #     Symbol
-  #
-  # If the value is +nil+, then no converstion will be performed.
-  #
-  def getopt( *args )
-    opts = args.last.instance_of?(Hash) ? args.pop : {}
-    key, default = args
-
-    val = if has_key?(key);                self[key]
-          elsif has_key?(key.to_s);        self[key.to_s]
-          elsif has_key?(key.to_s.intern); self[key.to_s.intern]
-          else default end
-
-    return if val.nil?
-    return val unless opts.has_key?(:as)
-
-    case opts[:as].name.intern
-    when :Integer; Integer(val)
-    when :Float;   Float(val)
-    when :Array;   Array(val)
-    when :String;  String(val)
-    when :Symbol;  String(val).intern
-    else val end
-  end
-end
-
-# --------------------------------------------------------------------------
-class String
-
-  # call-seq:
-  #    reduce( width, ellipses = '...' )    #=> string
-  #
-  # Reduce the size of the current string to the given _width_ by removing
-  # characters from the middle of the string and replacing them with
-  # _ellipses_. If the _width_ is greater than the length of the string, the
-  # string is returned unchanged. If the _width_ is less than the length of
-  # the _ellipses_, then the _ellipses_ are returned.
-  #
-  def reduce( width, ellipses = '...')
-    raise ArgumentError, "width cannot be negative: #{width}" if width < 0
-
-    return self if length <= width
-
-    remove = length - width + ellipses.length
-    return ellipses.dup if remove >= length
-
-    left_end = (length + 1 - remove) / 2
-    right_start = left_end + remove
-
-    left = self[0,left_end]
-    right = self[right_start,length-right_start]
-
-    left << ellipses << right
-  end
-end
-
-# --------------------------------------------------------------------------
-class Module
-
-  # call-seq:
-  #    logger_name    #=> string
-  #
-  # Returns a predictable logger name for the current module or class. If
-  # used within an anonymous class, the first non-anonymous class name will
-  # be used as the logger name. If used within a meta-class, the name of the
-  # actual class will be used as the logger name. If used within an
-  # anonymous module, the string 'anonymous' will be returned.
-  #
-  def logger_name
-    return name unless name.nil? or name.empty?
-
-    # check if this is a metaclass (or eigenclass)
-    if ancestors.include? Class
-      inspect =~ %r/#<Class:([^#>]+)>/
-      return $1
-    end
-
-    # see if we have a superclass
-    if respond_to? :superclass
-      return superclass.logger_name
-    end
-
-    # we are an anonymous module
-    ::Logging.log_internal(-2) {
-      'cannot return a predictable, unique name for anonymous modules'
-    }
-    return 'anonymous'
-  end
-end
-
-# --------------------------------------------------------------------------
-module Kernel
-
-  # call-seq:
-  #    require?( string )
-  #
-  # Attempt to the load the library named _string_ using the standard
-  # Kernel#require method. Returns +true+ if the library was successfully
-  # loaded. Returns +false+ if the library could not be loaded. This method
-  # will never raise an exception.
-  #
-  def require?( string )
-    require string
-    return true
-  rescue LoadError
-    return false
-  end
-end  # module Kernel
-
-# --------------------------------------------------------------------------
-class ReentrantMutex < Mutex
-
-  def initialize
-    super
-    @locker = nil
-  end
-
-  alias :original_synchronize :synchronize
-
-  def synchronize
-    if @locker == Thread.current
-      yield
-    else
-      original_synchronize {
-        begin
-          @locker = Thread.current
-          yield
-        ensure
-          @locker = nil
-        end
-      }
-    end
-  end
-end  # class ReentrantMutex
-
-# EOF

data/lib/logging/lib/spec/logging_helper.rb

@@ -1,34 +0,0 @@
-
-module Spec
-  module LoggingHelper
-
-    # Capture log messages from the Logging framework and make them
-    # available via a @log_output instance variable. The @log_output
-    # supports a readline method to access the log messags.
-    #
-    def capture_log_messages( opts = {} )
-      from = opts.getopt(:from, 'root')
-      to = opts.getopt(:to, '__rspec__')
-      exclusive = opts.getopt(:exclusive, true)
-
-      appender = Logging::Appenders[to] || Logging::Appenders::StringIo.new(to)
-      logger = Logging::Logger[from]
-      if exclusive
-        logger.appenders = appender
-      else
-        logger.add_appenders(appender)
-      end
-
-      before(:all) do
-        @log_output = Logging::Appenders[to]
-      end
-
-      before(:each) do
-        @log_output.reset
-      end
-    end
-
-  end  # module LoggingHelper
-end  # module Spec
-
-# EOF

data/lib/logging/test/appenders/test_buffered_io.rb

@@ -1,176 +0,0 @@
-
-require File.join(File.dirname(__FILE__), %w[.. setup])
-
-module TestLogging
-module TestAppenders
-
-  class TestBufferedIO < Test::Unit::TestCase
-    include LoggingTestCase
-
-    def setup
-      super
-      @appender = Logging.appenders.string_io(
-        'test_appender', :auto_flushing => 3, :immediate_at => :error
-      )
-      @appender.clear
-      @sio = @appender.sio
-      @levels = Logging::LEVELS
-      begin readline rescue EOFError end
-    end
-
-    def test_append
-      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      assert_nil(readline)
-
-      @appender.append event
-      assert_nil(readline)
-
-      event.level = @levels['debug']
-      event.data = 'the big log message'
-      @appender.append event
-
-      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
-      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
-      assert_equal "DEBUG  TestLogger : the big log message\n", readline
-      assert_nil(readline)
-
-      @appender.close
-      assert_raise(RuntimeError) {@appender.append event}
-    end
-
-    def test_append_error
-      # setup an internal logger to capture error messages from the IO
-      # appender
-      log = Logging.appenders.string_io('__internal_io')
-      Logging.logger[Logging].add_appenders(log)
-      Logging.logger[Logging].level = 'all'
-
-
-      # close the string IO object so we get an error
-      @sio.close
-      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      assert_nil(log.readline)
-
-      @appender.append event
-      assert_nil(log.readline)
-
-      @appender.append event
-      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
-      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
-
-      assert_equal false, @appender.closed?
-      assert_equal 5, @appender.level
-    end
-
-    def test_auto_flushing
-      assert_raise(ArgumentError) {
-        @appender.auto_flushing = Object.new
-      }
-
-      assert_raise(ArgumentError) {
-        @appender.auto_flushing = -1
-      }
-    end
-
-    def test_close
-      assert_equal false, @sio.closed?
-      assert_equal false, @appender.closed?
-
-      @appender.close
-      assert_equal true, @sio.closed?
-      assert_equal true, @appender.closed?
-
-      [STDIN, STDERR, STDOUT].each do |io|
-        @appender = Logging.appenders.io('test', io)
-        @appender.close
-        assert_equal false, io.closed?
-        assert_equal true, @appender.closed?
-      end
-    end
-
-    def test_concat
-      @appender << "this is a test message\n"
-      assert_nil(readline)
-
-      @appender << "this is another message\n"
-      assert_nil(readline)
-
-      @appender << "some other line\n"
-
-      assert_equal "this is a test message\n", readline
-      assert_equal "this is another message\n", readline
-      assert_equal "some other line\n", readline
-      assert_nil(readline)
-
-      @appender.close
-      assert_raise(RuntimeError) {@appender << 'message'}
-    end
-
-    def test_concat_error
-      # setup an internal logger to capture error messages from the IO
-      # appender
-      log = Logging.appenders.string_io('__internal_io')
-      Logging.logger[Logging].add_appenders(log)
-      Logging.logger[Logging].level = 'all'
-
-      # close the string IO object so we get an error
-      @sio.close
-      @appender << 'oopsy'
-      assert_nil(log.readline)
-
-      @appender << 'whoopsy'
-      assert_nil(log.readline)
-
-      @appender << 'pooh'
-      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
-      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
-
-      # and the appender does not close itself
-      assert_equal false, @appender.closed?
-      assert_equal 5, @appender.level
-    end
-
-    def test_flush
-      ary = []
-      @sio.instance_variable_set :@ary, ary
-      def @sio.flush() @ary << :flush end
-
-      @appender << "this is a test message\n"
-      assert_nil(readline)
-
-      @appender.flush
-      assert_equal :flush, ary.pop
-      assert_equal "this is a test message\n", readline
-      assert_nil(readline)
-    end
-
-    def test_immediate_at
-      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      assert_nil(readline)
-
-      event.level = @levels['error']
-      event.data = 'an error message'
-      @appender.append event
-
-      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
-      assert_equal "ERROR  TestLogger : an error message\n", readline
-      assert_nil(readline)
-    end
-
-    private
-    def readline
-      @appender.readline
-    end
-
-  end  # class TestBufferedIO
-
-end  # module TestAppenders
-end  # module TestLogging
-
-# EOF

data/lib/logging/test/appenders/test_console.rb

@@ -1,66 +0,0 @@
-
-require File.join(File.dirname(__FILE__), %w[.. setup])
-
-module TestLogging
-module TestAppenders
-
-  class TestStdout < Test::Unit::TestCase
-    include LoggingTestCase
-
-    def test_initialize
-      Logging::Repository.instance
-
-      appender = Logging.appenders.stdout
-      assert_equal 'stdout', appender.name
-      assert_same STDOUT, appender.instance_variable_get(:@io)
-
-      appender.close
-      assert_equal true, appender.closed?
-      assert_equal false, STDOUT.closed?
-
-      appender = Logging.appenders.stdout('foo')
-      assert_equal 'foo', appender.name
-
-      appender = Logging.appenders.stdout(:level => :warn)
-      assert_equal 'stdout', appender.name
-      assert_equal 2, appender.level
-
-      appender = Logging.appenders.stdout('bar', :level => :error)
-      assert_equal 'bar', appender.name
-      assert_equal 3, appender.level
-    end
-
-  end  # class TestStdout
-
-  class TestStderr < Test::Unit::TestCase
-    include LoggingTestCase
-
-    def test_initialize
-      Logging::Repository.instance
-
-      appender = Logging.appenders.stderr
-      assert_equal 'stderr', appender.name
-      assert_same STDERR, appender.instance_variable_get(:@io)
-
-      appender.close
-      assert_equal true, appender.closed?
-      assert_equal false, STDERR.closed?
-
-      appender = Logging.appenders.stderr('foo')
-      assert_equal 'foo', appender.name
-
-      appender = Logging.appenders.stderr(:level => :warn)
-      assert_equal 'stderr', appender.name
-      assert_equal 2, appender.level
-
-      appender = Logging.appenders.stderr('bar', :level => :error)
-      assert_equal 'bar', appender.name
-      assert_equal 3, appender.level
-    end
-
-  end  # class TestStderr
-
-end  # module TestAppenders
-end  # module TestLogging
-
-# EOF

data/lib/logging/test/appenders/test_email.rb

@@ -1,170 +0,0 @@
-
-require File.join(File.dirname(__FILE__), %w[.. setup])
-require 'flexmock'
-
-module TestLogging
-module TestAppenders
-
-  class TestEmail < Test::Unit::TestCase
-    include FlexMock::TestCase
-    include LoggingTestCase
-
-    def setup
-      super
-
-      flexmock(Net::SMTP).new_instances do |m|
-        m.should_receive(:start).at_least.once.with(
-            'test.logging', 'test', 'test', :cram_md5, Proc).and_yield(m)
-        m.should_receive(:sendmail).at_least.once.with(String, 'me', ['you'])
-      end
-
-      @appender = Logging.appenders.email('email',
-          'from' => 'me', 'to' => 'you',
-          :buffer_size => '3', :immediate_at => 'error, fatal',
-          :domain => 'test.logging', :acct => 'test', :passwd => 'test'
-      )
-      @levels = Logging::LEVELS
-    end
-
-    def test_initialize
-      assert_raise(ArgumentError, 'Must specify from address') {
-        Logging.appenders.email('email')
-      }
-      assert_raise(ArgumentError, 'Must specify to address') {
-        Logging.appenders.email('email', :from => 'me')
-      }
-      assert_nothing_raised {
-        Logging.appenders.email('email', :from => 'me', :to => 'you')
-      }
-
-      appender = Logging.appenders.email('email',
-          'from' => 'me', 'to' => 'you'
-      )
-
-      assert_equal(100, appender.auto_flushing)
-      assert_equal([], appender.instance_variable_get(:@immediate))
-      assert_equal('localhost', appender.server)
-      assert_equal(25, appender.port)
-
-      domain = ENV['HOSTNAME'] || 'localhost.localdomain'
-      assert_equal(domain, appender.domain)
-      assert_equal(nil, appender.acct)
-      assert_equal(:cram_md5, appender.authtype)
-      assert_equal("Message of #{$0}", appender.subject)
-
-      appender = Logging.appenders.email('email',
-          'from' => 'lbrinn@gmail.com', 'to' => 'everyone',
-          :buffsize => '1000', :immediate_at => 'error, fatal',
-          :server => 'smtp.google.com', :port => '443',
-          :domain => 'google.com', :acct => 'lbrinn',
-          :passwd => '1234', :authtype => 'tls',
-          :subject => "I'm rich and you're not"
-      )
-
-      assert_equal('lbrinn@gmail.com', appender.instance_variable_get(:@from))
-      assert_equal(['everyone'], appender.instance_variable_get(:@to))
-      assert_equal(1000, appender.auto_flushing)
-      assert_equal('1234', appender.instance_variable_get(:@passwd))
-      assert_equal([nil, nil, nil, true, true],
-                   appender.instance_variable_get(:@immediate))
-      assert_equal('smtp.google.com', appender.server)
-      assert_equal(443, appender.port)
-      assert_equal('google.com', appender.domain)
-      assert_equal('lbrinn', appender.acct)
-      assert_equal(:tls, appender.authtype)
-      assert_equal("I'm rich and you're not", appender.subject)
-
-      appender = Logging.appenders.email('email',
-          'from' => 'me', 'to' => 'you', :auto_flushing => 42
-      )
-      assert_equal(42, appender.auto_flushing)
-    end
-
-    def test_append
-      # with auto_flushing enabled, mail will be sent each time a log event
-      # occurs
-      @appender.auto_flushing = true
-      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      # increase the buffer size and log a few events
-      @appender.auto_flushing = 3
-      @appender.append event
-      @appender.append event
-      assert_equal(2, @appender.buffer.length)
-
-      @appender.append event
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      # error and fatal messages should be send immediately (no buffering)
-      error = Logging::LogEvent.new('ErrLogger', @levels['error'],
-                                    'error message', false)
-      fatal = Logging::LogEvent.new('FatalLogger', @levels['fatal'],
-                                    'fatal message', false)
-
-      @appender.append event
-      @appender.append fatal
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      @appender.append error
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      @appender.append event
-      assert_equal(1, @appender.buffer.length)
-    end
-
-    def test_concat
-      # with auto_flushing enabled, mail will be sent each time a log event
-      # occurs
-      @appender.auto_flushing = true
-      @appender << 'test message'
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      # increase the buffer size and log a few events
-      @appender.auto_flushing = 3
-      @appender << 'another test message'
-      @appender << 'a second test message'
-      assert_equal(2, @appender.buffer.length)
-
-      @appender << 'a third test message'
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-    end
-
-    def test_flush
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      @appender << 'test message'
-      assert_equal(2, @appender.buffer.length)
-
-      @appender.flush
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-    end
-
-    def test_close
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      @appender << 'test message'
-      assert_equal(2, @appender.buffer.length)
-
-      @appender.close
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-      assert(@appender.closed?)
-    end
-
-  end  # class TestEmail
-end  # module TestLogging
-end  # module TestAppenders
-
-# EOF