depengine 0.0.1

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/logger.rb

@@ -0,0 +1,199 @@
+# :include: rdoc/logger
+#
+# == Other Info
+# 
+# Version:: $Id$
+# Author:: Leon Torres <leon(at)ugcs.caltech.edu>
+
+require "log4r/outputter/outputter"
+require "log4r/repository"
+require "log4r/loggerfactory"
+require "log4r/staticlogger"
+
+module Log4r
+  
+  # See log4r/logger.rb
+  class Logger
+    attr_reader :name, :fullname, :path, :level, :parent
+    attr_reader :additive, :trace, :outputters
+
+    # Logger requires a name. The last 3 parameters are:
+    #
+    # level::     Do I have a level? (Otherwise, I'll inherit my parent's)
+    # additive::  Am I additive?
+    # trace::     Do I record the execution trace? (slows things a wee bit) 
+
+    def initialize(_fullname, _level=nil, _additive=true, _trace=false)
+      # validation
+      raise ArgumentError, "Logger must have a name", caller if _fullname.nil?
+      Log4rTools.validate_level(_level) unless _level.nil?
+      validate_name(_fullname)
+      
+      # create the logger
+      @fullname = _fullname
+      @outputters = []
+      @additive = _additive
+      deal_with_inheritance(_level)
+      LoggerFactory.define_methods(self)
+      self.trace = _trace
+      Repository[@fullname] = self
+    end
+
+    def validate_name(_fullname)
+      parts = _fullname.split Log4rConfig::LoggerPathDelimiter
+      for part in parts
+        raise ArgumentError, "Malformed path", caller[1..-1] if part.empty?
+      end
+    end
+    private :validate_name
+
+    # Parses name for location in heiarchy, sets the parent, and
+    # deals with level inheritance
+
+    def deal_with_inheritance(_level)
+      mypath = @fullname.split Log4rConfig::LoggerPathDelimiter
+      @name = mypath.pop
+      if mypath.empty? # then root is my daddy
+        @path = ""
+        # This is one of the guarantees that RootLogger gets created
+        @parent = Logger.root
+      else
+        @path = mypath.join(Log4rConfig::LoggerPathDelimiter)
+        @parent = Repository.find_ancestor(@path)
+        @parent = Logger.root if @parent.nil?
+      end
+      # inherit the level if no level defined
+      if _level.nil? then @level = @parent.level
+      else @level = _level end
+      Repository.reassign_any_children(self)
+    end
+    private :deal_with_inheritance
+
+    # Set the logger level dynamically. Does not affect children.
+    def level=(_level)
+      Log4rTools.validate_level(_level)
+      @level = _level
+      LoggerFactory.define_methods(self)
+      Logger.log_internal {"Logger '#{@fullname}' set to #{LNAMES[@level]}"}
+      @level
+    end
+
+    # Return array of defined levels.
+    def levels
+      LNAMES
+    end
+
+    # Set the additivity of the logger dynamically. True or false.
+    def additive=(_additive)
+      @additive = _additive
+      LoggerFactory.define_methods(self)
+      Logger.log_internal {"Logger '#{@fullname}' is additive"}
+      @additive
+    end
+
+    # Set whether the logger traces. Can be set dynamically. Defaults
+    # to false and understands the strings 'true' and 'false'.
+    def trace=(_trace)
+      @trace =
+        case _trace
+        when "true", true then true
+        else false end
+      LoggerFactory.define_methods(self)
+      Logger.log_internal {"Logger '#{@fullname}' is tracing"} if @trace
+      @trace
+    end
+
+    # Please don't reset the parent
+    def parent=(parent)
+      @parent = parent
+    end
+    
+    # Set the Outputters dynamically by name or reference. Can be done any
+    # time.
+    def outputters=(_outputters)
+      @outputters.clear
+      add(*_outputters)
+    end  
+
+    # Add outputters by name or by reference. Can be done any time.
+    def add(*_outputters)
+      for thing in _outputters
+        o = (thing.kind_of?(Outputter) ? thing : Outputter[thing])
+        # some basic validation
+        if not o.kind_of?(Outputter)
+          raise TypeError, "Expected kind of Outputter, got #{o.class}", caller
+        elsif o.nil?
+          raise TypeError, "Couldn't find Outputter '#{thing}'", caller
+        end
+        @outputters.push o
+        Logger.log_internal {"Added outputter '#{o.name}' to '#{@fullname}'"}
+      end
+      @outputters
+    end
+
+    # Remove outputters from this logger by name only. Can be done any time.
+    def remove(*_outputters)
+      for name in _outputters
+        o = Outputter[name]
+        @outputters.delete o
+        Logger.log_internal {"Removed outputter '#{o.name}' from '#{@fullname}'"}
+      end
+    end
+
+    def is_root?; false end
+
+    def ==(other)
+      return true if self.object_id == other.object_id
+    end
+  end
+
+
+  # RootLogger should be retrieved with Logger.root or Logger.global.
+  # It's supposed to be transparent.
+  #--
+  # We must guarantee the creation of RootLogger before any other Logger
+  # or Outputter gets their logging methods defined. There are two 
+  # guarantees in the code:
+  #
+  # * Logger#deal_with_inheritance - calls RootLogger.instance when
+  #   a new Logger is created without a parent. Parents must exist, therefore
+  #   RootLogger is forced to be created.
+  #
+  # * OutputterFactory.create_methods - Calls Logger.root first. So if
+  #   an Outputter is created, RootLogger is also created.
+  #
+  # When RootLogger is created, it calls
+  # Log4r.define_levels(*Log4rConfig::LogLevels). This ensures that the 
+  # default levels are loaded if no custom ones are.
+
+  class RootLogger < Logger
+    include Singleton
+
+    def initialize
+      Log4r.define_levels(*Log4rConfig::LogLevels) # ensure levels are loaded
+      @level = ALL
+      @outputters = []
+      Repository['root'] = self
+      Repository['global'] = self
+      LoggerFactory.undefine_methods(self)
+    end
+
+    def is_root?; true end
+
+    # Set the global level. Any loggers defined thereafter will
+    # not log below the global level regardless of their levels.
+
+    def level=(alevel); @level = alevel end
+
+    # Does nothing
+    def outputters=(foo); end
+    # Does nothing
+    def trace=(foo); end
+    # Does nothing
+    def additive=(foo); end
+    # Does nothing
+    def add(*foo); end
+    # Does nothing
+    def remove(*foo); end
+  end
+end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/loggerfactory.rb

@@ -0,0 +1,89 @@
+# :nodoc:
+# Version:: $Id$
+
+require "log4r/base"
+require "log4r/repository"
+require 'log4r/logevent'
+
+module Log4r
+class Logger
+  class LoggerFactory #:nodoc:
+
+    # we want to log iff root.lev <= lev && logger.lev <= lev
+    # BTW, root is guaranteed to be defined by this point
+    def self.define_methods(logger)
+      return if logger.is_root?
+      undefine_methods(logger)
+      globlev = Repository['root'].level
+      return if logger.level == OFF or globlev == OFF
+      toggle_methods(globlev, logger)
+    end
+
+    # set logging methods to null defaults
+    def self.undefine_methods(logger)
+      for lname in LNAMES
+        next if lname == 'OFF'|| lname == 'ALL'
+        unset_log(logger, lname)
+        set_false(logger, lname)
+      end
+      set_false(logger, 'all')
+      set_true(logger, 'off')
+    end
+    
+    # toggle methods >= globlev that are also >= level
+    def self.toggle_methods(globlev, logger)
+      for lev in globlev...LEVELS # satisfies >= globlev
+        next if lev < logger.level # satisfies >= level
+        next if LNAMES[lev] == 'OFF'
+        next if LNAMES[lev] == 'ALL'
+        set_log(logger, LNAMES[lev])
+        set_true(logger, LNAMES[lev])
+      end
+      if logger.level == ALL
+        set_true(logger, 'all')
+      end
+      if logger.level != OFF && globlev != OFF
+        set_false(logger, 'off')
+      end
+    end
+
+    # And now, the weird dynamic method definitions! :)
+  
+    def self.unset_log(logger, lname)
+      mstr="def logger.#{lname.downcase}(data=nil, propagated=false); end"
+      module_eval mstr
+    end
+    
+    # Logger logging methods are defined here.
+    def self.set_log(logger, lname) 
+      # invoke caller iff the logger invoked is tracing
+      tracercall = (logger.trace ? "caller" : "nil")
+      # maybe pass parent a logevent. second arg is the switch
+      if logger.additive && !logger.parent.is_root?
+        parentcall = "@parent.#{lname.downcase}(event, true)"
+      end
+      mstr = %-
+        def logger.#{lname.downcase}(data=nil, propagated=false)
+          if propagated then event = data
+          else
+            data = yield if block_given?
+            event = LogEvent.new(#{lname}, self, #{tracercall}, data)
+          end
+          @outputters.each {|o| o.#{lname.downcase}(event) }
+          #{parentcall}
+        end
+      -
+      module_eval mstr
+    end
+    
+    def self.set_false(logger, lname)
+      module_eval "def logger.#{lname.downcase}?; false end"
+    end
+
+    def self.set_true(logger, lname)
+      module_eval "def logger.#{lname.downcase}?; true end"
+    end
+
+  end
+end
+end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/logserver.rb

@@ -0,0 +1,28 @@
+# :include: rdoc/logserver
+
+require 'log4r/logger'
+require 'log4r/lib/drbloader'
+
+module Log4r
+  # See log4r/logserver.rb
+  class LogServer < Logger
+    attr_reader :uri
+
+    # A valid ROMP uri must be specified.
+    def initialize(_fullname, _uri, _level=nil, 
+                   _additive=true, _trace=false, &accept)
+      super(_fullname, _level, _additive, _trace)
+      @uri = _uri
+      start_server(_uri, accept)
+      Logger.log_internal {"LogServer started at #{@uri}"}
+    end
+
+    if HAVE_ROMP
+      include ROMPServer
+    else
+      def initialize(*args)
+        raise RuntimeError, "LogServer not supported. ROMP is required", caller
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/outputter/consoleoutputters.rb

@@ -0,0 +1,18 @@
+# :nodoc:
+require "log4r/outputter/iooutputter"
+
+module Log4r
+  # Same as IOOutputter(name, $stdout)
+  class StdoutOutputter < IOOutputter
+    def initialize(_name, hash={})
+      super(_name, $stdout, hash)
+    end
+  end
+
+  # Same as IOOutputter(name, $stderr)
+  class StderrOutputter < IOOutputter
+    def initialize(_name, hash={})
+      super(_name, $stderr, hash)
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/outputter/datefileoutputter.rb

@@ -0,0 +1,117 @@
+# = DateFileOutputter
+#
+# Subclass of FileOutputter that changes the log file daily. When a new
+# day begins, a new file is created with the date included in the name.
+#
+# == Usage
+#
+#   df_out = DateFileOutputter.new('name',
+#              :dirname="/tmp", :date_pattern=>"%m-%d" 
+#            )
+#
+# == Rate of Change
+#
+# A new logfile is created whenever the current time as formatted by the date
+# pattern no longer matches the previous time. (This is a simple String 
+# comparison.) So, in order to change the frequency of the rollover, just
+# alter the date pattern to match how fast the files should be generated. 
+# For instance, to generate files by the minute,
+#
+#   df_out.date_pattern = "%M"
+#
+# This causes the following files to show up one minute apart, asuming the
+# script starts at the 4th minute of the hour:
+#
+#   file_04.rb
+#   file_05.rb
+#   file_06.rb
+#   ...
+#
+# The only limitation of this approach is that the precise time cannot be
+# recorded as the smallest time interval equals the rollover period for this
+# system.
+
+require "log4r/outputter/fileoutputter"
+require "log4r/staticlogger"
+
+module Log4r
+
+  # Additional hash arguments are:
+  #
+  # [<tt>:dirname</tt>]         Directory of the log file
+  # [<tt>:date_pattern</tt>]    Time.strftime format string (default is "%Y-%m-%d")
+
+  class DateFileOutputter < FileOutputter
+    DEFAULT_DATE_FMT = "%Y-%m-%d"
+
+    def initialize(_name, hash={})
+      @DatePattern = (hash[:date_pattern] or hash['date_pattern'] or
+                      DEFAULT_DATE_FMT)
+      @DateStamp = Time.now.strftime( @DatePattern);
+      _dirname = (hash[:dirname] or hash['dirname'])
+      # hash[:dirname] masks hash[:filename]
+      if _dirname
+        if not FileTest.directory?( _dirname)
+          raise StandardError, "'#{_dirname}' must be a valid directory", caller
+        end
+      end
+
+      _filename = (hash[:filename] or hash['filename'])
+      if _filename.nil?
+        @filebase = File.basename( $0, '.rb') + ".log"
+      else
+        @filebase = File.basename((hash[:filename] or hash['filename'] or ""))
+      end
+
+      # Get rid of the 'nil' in the path
+      path = [_dirname, @filebase.sub(/(\.\w*)$/, "_#{@DateStamp}" + '\1')].compact
+      hash[:filename] = hash['filename'] = File.join(path)
+
+      super(_name, hash)
+    end
+
+    #######
+    private
+    #######
+
+    # perform the write
+    def write(data)
+      change if requiresChange
+      super
+    end
+
+    # construct a new filename from the DateStamp
+    def makeNewFilename
+        @DateStamp = Time.now.strftime( @DatePattern);
+        @filename = File.join(File.dirname(@filename),
+                    @filebase.sub(/(\.\w*)$/, "_#{@DateStamp}" + '\1'))
+    end
+
+    # does the file require a change?
+    def requiresChange
+      _DateStamp = Time.now.strftime( @DatePattern);
+      if not _DateStamp == @DateStamp
+        @DateStamp = _DateStamp
+        return true
+      end
+      false
+    end
+
+    # change the file 
+    def change
+      begin
+        @out.close
+      rescue
+        Logger.log_internal {
+          "DateFileOutputter '#{@name}' could not close #{@filename}"
+        }
+      end
+      makeNewFilename
+      @out = File.new(@filename, (@trunc ? "w" : "a"))
+      Logger.log_internal {
+        "DateFileOutputter '#{@name}' now writing to #{@filename}"
+      }
+    end
+  end
+
+end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/outputter/emailoutputter.rb

@@ -0,0 +1,143 @@
+# :include: ../rdoc/emailoutputter
+
+require 'log4r/outputter/outputter'
+require 'log4r/staticlogger'
+require 'net/smtp'
+
+module Log4r
+
+  class EmailOutputter < Outputter
+    attr_reader :server, :port, :domain, :acct, :authtype, :subject, :tls
+
+    def initialize(_name, hash={})
+      super(_name, hash)
+      validate(hash)
+      @buff = []
+      begin 
+	Logger.log_internal {
+	  "EmailOutputter '#{@name}' running SMTP client on #{@server}:#{@port}"
+	}
+      rescue Exception => e
+	Logger.log_internal(-2) {
+	  "EmailOutputter '#{@name}' failed to start SMTP client!"
+	}
+	Logger.log_internal {e}
+	self.level = OFF
+	raise e
+      end
+    end
+
+    # send out an email with the current buffer
+    def flush
+      synch { send_mail }
+      Logger.log_internal {"Flushed EmailOutputter '#{@name}'"}
+    end
+
+    private
+
+    def validate(hash)
+      @buffsize = (hash[:buffsize] or hash['buffsize'] or 100).to_i
+      @formatfirst = Log4rTools.decode_bool(hash, :formatfirst, false)
+      decode_immediate_at(hash)
+      validate_smtp_params(hash)
+    end
+
+    def decode_immediate_at(hash)
+      @immediate = Hash.new
+      _at = (hash[:immediate_at] or hash['immediate_at'])
+      return if _at.nil?
+      Log4rTools.comma_split(_at).each {|lname|
+	level = LNAMES.index(lname)
+	if level.nil?
+	  Logger.log_internal(-2) do
+	    "EmailOutputter: skipping bad immediate_at level name '#{lname}'"
+	  end
+	  next
+	end
+	@immediate[level] = true
+      }
+    end
+
+    def validate_smtp_params(hash)
+      @from = (hash[:from] or hash['from'])
+      raise ArgumentError, "Must specify from address" if @from.nil?
+      _to = (hash[:to] or hash['to'] or "")
+      @to = Log4rTools.comma_split(_to) 
+      raise ArgumentError, "Must specify recepients" if @to.empty?
+      @server = (hash[:server] or hash['server'] or 'localhost')
+      @port = (hash[:port] or hash['port'] or 25).to_i
+      @domain = (hash[:domain] or hash['domain'] or ENV['HOSTNAME'])
+      @acct = (hash[:acct] or hash['acct'])
+      @passwd = (hash[:passwd] or hash['passwd'])
+      @authtype = (hash[:authtype] or hash['authtype'] or :cram_md5).to_s.to_sym
+      @subject = (hash[:subject] or hash['subject'] or "Message of #{$0}")
+      @tls = (hash[:tls] or hash['tls'] or nil)
+      @params = [@server, @port, @domain, @acct, @passwd, @authtype]
+    end
+
+    def canonical_log(event)
+      synch {
+	@buff.push case @formatfirst
+          when true then @formatter.format event
+          else event 
+          end
+        send_mail if @buff.size >= @buffsize or @immediate[event.level]
+      }
+    end
+
+    def send_mail
+      msg = 
+        case @formatfirst
+        when true then @buff.join 
+        else @buff.collect{|e| @formatter.format e}.join 
+        end
+
+      ### build a mail header for RFC 822
+      rfc822msg =
+        "From: #{@from}\n" +
+        "To: #{@to}\n" +
+        "Subject: #{@subject}\n" +
+        "Date: #{Time.now.strftime( "%a, %d %b %Y %H:%M:%S %z %Z")}\n" +
+        "Message-Id: <#{"%.8f" % Time.now.to_f}@#{@domain}>\n\n" +
+        "#{msg}"
+  
+      ### send email
+      begin
+  
+	smtp = Net::SMTP.new( @server, @port )
+
+        if ( @tls )
+
+	  # >1.8.7 has smtp_tls built in, 1.8.6 requires smtp_tls
+	  if RUBY_VERSION < "1.8.7" then
+	    begin
+	      require 'rubygems'
+	      require 'smtp_tls'
+	      smtp.enable_starttls if smtp.respond_to?(:enable_starttls)
+	    rescue LoadError => e
+	      Logger.log_internal(-2) {
+	        "EmailOutputter '#{@name}' unable to load smtp_tls, needed to support TLS on Ruby versions < 1.8.7"
+	      }
+	      raise e
+	    end
+	  else # RUBY_VERSION >= 1.8.7
+	    smtp.enable_starttls_auto if smtp.respond_to?(:enable_starttls_auto)
+	  end
+
+	end # if @tls
+
+        smtp.start(@domain, @acct, @passwd, @authtype) do |s|
+	  s.send_message(rfc822msg, @from, @to)
+        end
+      rescue Exception => e
+        Logger.log_internal(-2) {
+	  "EmailOutputter '#{@name}' couldn't send email!"
+        }
+        Logger.log_internal {e}
+        self.level = OFF
+        raise e
+      ensure @buff.clear
+      end # begin
+    end # def send_mail
+  end # class EmailOutputter
+end # module Log4r

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/outputter/fileoutputter.rb

@@ -0,0 +1,56 @@
+# :nodoc:
+# Version:: $Id$
+
+require "log4r/outputter/iooutputter"
+require "log4r/staticlogger"
+
+module Log4r
+
+  # Convenience wrapper for File. Additional hash arguments are:
+  #
+  # [<tt>:filename</tt>]   Name of the file to log to.
+  # [<tt>:trunc</tt>]      Truncate the file?
+  class FileOutputter < IOOutputter
+    attr_reader :trunc, :filename
+
+    def initialize(_name, hash={})
+      super(_name, nil, hash)
+
+      @trunc = Log4rTools.decode_bool(hash, :trunc, false)
+      _filename = (hash[:filename] or hash['filename'])
+      @create = Log4rTools.decode_bool(hash, :create, true)
+
+      if _filename.class != String
+        raise TypeError, "Argument 'filename' must be a String", caller
+      end
+
+      # file validation
+      if FileTest.exist?( _filename )
+        if not FileTest.file?( _filename )
+          raise StandardError, "'#{_filename}' is not a regular file", caller
+        elsif not FileTest.writable?( _filename )
+          raise StandardError, "'#{_filename}' is not writable!", caller
+        end
+      else # ensure directory is writable
+        dir = File.dirname( _filename )
+        if not FileTest.writable?( dir )
+          raise StandardError, "'#{dir}' is not writable!"
+        end
+      end
+
+      @filename = _filename
+      if ( @create == true ) then
+	@out = File.new(@filename, (@trunc ? "w" : "a")) 
+	Logger.log_internal {
+	  "FileOutputter '#{@name}' writing to #{@filename}"
+	}
+      else
+	Logger.log_internal {
+	  "FileOutputter '#{@name}' called with :create == false, #{@filename}"
+	}
+      end
+    end
+
+  end
+  
+end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/lib/log4r/outputter/iooutputter.rb

@@ -0,0 +1,55 @@
+# :nodoc:
+require "log4r/outputter/outputter"
+require "log4r/staticlogger"
+
+module Log4r
+  
+  ##
+  # IO Outputter invokes print then flush on the wrapped IO
+  # object. If the IO stream dies, IOOutputter sets itself to OFF
+  # and the system continues on its merry way.
+  #
+  # To find out why an IO stream died, create a logger named 'log4r'
+  # and look at the output.
+
+  class IOOutputter < Outputter
+
+    # IOOutputter needs an IO object to write to.
+    def initialize(_name, _out, hash={})
+      super(_name, hash)
+      @out = _out
+    end
+
+    def closed?
+      @out.closed?
+    end
+
+    # Close the IO and sets level to OFF
+    def close
+      @out.close unless @out.nil?
+      @level = OFF
+      OutputterFactory.create_methods(self)
+      Logger.log_internal {"Outputter '#{@name}' closed IO and set to OFF"}
+    end
+
+    #######
+    private
+    #######
+    
+    # perform the write
+    def write(data)
+      begin
+        @out.print data
+        @out.flush
+      rescue IOError => ioe # recover from this instead of crash
+        Logger.log_internal {"IOError in Outputter '#{@name}'!"}
+        Logger.log_internal {ioe}
+        close
+      rescue NameError => ne
+        Logger.log_internal {"Outputter '#{@name}' IO is #{@out.class}!"}
+        Logger.log_internal {ne}
+        close
+      end
+    end
+  end
+end