filterfish-logging 0.9.8

data/lib/logging/repository.rb

@@ -0,0 +1,151 @@
+# $Id$
+
+require 'singleton'
+
+module Logging
+
+  # The Repository is a hash that stores references to all Loggers
+  # that have been created. It provides methods to determine parent/child
+  # relationships between Loggers and to retrieve Loggers from the hash.
+  #
+  class Repository
+    include Singleton
+
+    PATH_DELIMITER = '::'  # :nodoc:
+
+    # nodoc:
+    #
+    # This is a singleton class -- use the +instance+ method to obtain the
+    # +Repository+ instance.
+    #
+    def initialize
+      @h = {:root => ::Logging::RootLogger.new}
+    end
+
+    # call-seq:
+    #    instance[name]
+    #
+    # Returns the +Logger+ named _name_.
+    #
+    # When _name_ is a +String+ or a +Symbol+ it will be used "as is" to
+    # retrieve the logger. When _name_ is a +Class+ the class name will be
+    # used to retrieve the logger. When _name_ is an object the name of the
+    # object's class will be used to retrieve the logger.
+    #
+    # Example:
+    #
+    #   repo = Repository.instance
+    #   obj = MyClass.new
+    #
+    #   log1 = repo[obj]
+    #   log2 = repo[MyClass]
+    #   log3 = repo['MyClass']
+    #
+    #   log1.object_id == log2.object_id         # => true
+    #   log2.object_id == log3.object_id         # => true
+    #
+    def []( key ) @h[to_key(key)] end
+
+    # call-seq:
+    #    instance[name] = logger
+    #
+    # Stores the _logger_ under the given _name_.
+    #
+    # When _name_ is a +String+ or a +Symbol+ it will be used "as is" to
+    # store the logger. When _name_ is a +Class+ the class name will be
+    # used to store the logger. When _name_ is an object the name of the
+    # object's class will be used to store the logger.
+    #
+    def []=( key, val ) @h[to_key(key)] = val end
+
+    # call-seq:
+    #    fetch( name )
+    #
+    # Returns the +Logger+ named _name_. An +IndexError+ will be raised if
+    # the logger does not exist.
+    #
+    # When _name_ is a +String+ or a +Symbol+ it will be used "as is" to
+    # retrieve the logger. When _name_ is a +Class+ the class name will be
+    # used to retrieve the logger. When _name_ is an object the name of the
+    # object's class will be used to retrieve the logger.
+    #
+    def fetch( key ) @h.fetch(to_key(key)) end
+
+    # call-seq:
+    #    has_logger?( name )
+    #
+    # Returns +true+ if the given logger exists in the repository. Returns
+    # +false+ if this is not the case.
+    #
+    # When _name_ is a +String+ or a +Symbol+ it will be used "as is" to
+    # retrieve the logger. When _name_ is a +Class+ the class name will be
+    # used to retrieve the logger. When _name_ is an object the name of the
+    # object's class will be used to retrieve the logger.
+    #
+    def has_logger?( key ) @h.has_key?(to_key(key)) end
+
+    # call-seq:
+    #    parent( key )
+    #
+    # Returns the parent logger for the logger identified by _key_ where
+    # _key_ follows the same identification rules described in
+    # +Repository#[]+. A parent is returned regardless of the
+    # existence of the logger referenced by _key_.
+    #
+    def parent( key )
+      key = to_key(key)
+      a = key.split PATH_DELIMITER
+
+      p = @h[:root]
+      while a.slice!(-1) and !a.empty?
+        k = a.join PATH_DELIMITER
+        if @h.has_key? k then p = @h[k]; break end
+      end
+      p
+    end
+
+    # call-seq:
+    #    children( key )
+    #
+    # Returns an array of the children loggers for the logger identified by
+    # _key_ where _key_ follows the same identification rules described in
+    # +Repository#[]+. Children are returned regardless of the
+    # existence of the logger referenced by _key_.
+    #
+    def children( key )
+      key = to_key(key)
+      depth = key.split(PATH_DELIMITER).length
+      rgxp = Regexp.new "^#{key}#{PATH_DELIMITER}"
+
+      a = @h.keys.map do |k|
+            if k =~ rgxp
+              l = @h[k]
+              d = l.parent.name.split(PATH_DELIMITER).length
+              if d <= depth then l else nil end
+            end
+          end
+      a.compact.sort
+    end
+
+    # call-seq:
+    #    to_key( key )
+    #
+    # Takes the given _key_ and converts it into a form that can be used to
+    # retrieve a logger from the +Repository+ hash.
+    #
+    # When _key_ is a +String+ or a +Symbol+ it will be returned "as is".
+    # When _key_ is a +Class+ the class name will be returned. When _key_ is
+    # an object the name of the object's class will be returned.
+    #
+    def to_key( key )
+      case key
+      when Symbol, String; key
+      when Class; key.name
+      when Object; key.class.name
+      end
+    end
+
+  end  # class Repository
+end  # module Logging
+
+# EOF

data/lib/logging/root_logger.rb

@@ -0,0 +1,60 @@
+# $Id$
+
+module Logging
+
+  # The root logger exists to ensure that all loggers have a parent and a
+  # defined logging level. If a logger is additive, eventually its log
+  # events will propogate up to the root logger.
+  #
+  class RootLogger < Logger
+
+    # undefine the methods that the root logger does not need
+    %w(additive additive= parent parent=).each do |m|
+      undef_method m.intern
+    end
+
+    # call-seq:
+    #    RootLogger.new
+    #
+    # Returns a new root logger instance. This method will be called only
+    # once when the +Repository+ singleton instance is created.
+    #
+    def initialize( )
+      ::Logging.init unless ::Logging.const_defined? 'MAX_LEVEL_LENGTH'
+
+      @name = 'root'
+      @appenders = []
+      @additive = false
+      @trace = false
+      self.level = 0
+    end
+
+    # call-seq:
+    #    log <=> other
+    #
+    # Compares this logger by name to another logger. The normal return codes
+    # for +String+ objects apply.
+    #
+    def <=>( other )
+      case other
+      when self; 0
+      when ::Logging::Logger; -1
+      else raise ArgumentError, 'expecting a Logger instance' end
+    end
+
+    # call-seq:
+    #    level = :all
+    #
+    # Set the level for the root logger. The functionality of this method is
+    # the same as +Logger#level=+, but setting the level to +nil+ for the
+    # root logger is not allowed. The level is silently set to :all.
+    #
+    def level=( level )
+      level ||= 0
+      super
+    end
+
+  end  # class RootLogger
+end  # module Logging
+
+# EOF

data/lib/logging/utils.rb

@@ -0,0 +1,44 @@
+# $Id$
+
+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
+
+# EOF

data/tasks/ann.rake

@@ -0,0 +1,78 @@
+# $Id$
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => PROJ.ann.file
+
+  desc "Send an email announcement"
+  task :email => PROJ.ann.file do
+    ann = PROJ.ann
+    from = ann.email[:from] || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,21 @@
+# $Id$
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if ARGV.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF

data/tasks/gem.rake

@@ -0,0 +1,106 @@
+# $Id$
+
+require 'rake/gempackagetask'
+
+namespace :gem do
+
+  PROJ.gem.spec = Gem::Specification.new do |s|
+    s.name = PROJ.name
+    s.version = PROJ.version
+    s.summary = PROJ.summary
+    s.authors = Array(PROJ.authors)
+    s.email = PROJ.email
+    s.homepage = Array(PROJ.url).first
+    s.rubyforge_project = PROJ.rubyforge.name
+    s.post_install_message = PROJ.gem.post_install_message
+
+    s.description = PROJ.description
+
+    PROJ.gem.dependencies.each do |dep|
+      s.add_dependency(*dep)
+    end
+
+    s.files = PROJ.gem.files
+    s.executables = PROJ.gem.executables.map {|fn| File.basename(fn)}
+    s.extensions = PROJ.gem.files.grep %r/extconf\.rb$/
+
+    s.bindir = 'bin'
+    dirs = Dir["{#{PROJ.libs.join(',')}}"]
+    s.require_paths = dirs unless dirs.empty?
+
+    incl = Regexp.new(PROJ.rdoc.include.join('|'))
+    excl = PROJ.rdoc.exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
+    excl = Regexp.new(excl.join('|'))
+    rdoc_files = PROJ.gem.files.find_all do |fn|
+                   case fn
+                   when excl; false
+                   when incl; true
+                   else false end
+                 end
+    s.rdoc_options = PROJ.rdoc.opts + ['--main', PROJ.rdoc.main]
+    s.extra_rdoc_files = rdoc_files
+    s.has_rdoc = true
+
+    if test ?f, PROJ.test.file
+      s.test_file = PROJ.test.file
+    else
+      s.test_files = PROJ.test.files.to_a
+    end
+  end
+
+  desc 'Show information about the gem'
+  task :debug do
+    puts PROJ.gem.spec.to_ruby
+  end
+
+  pkg = Rake::PackageTask.new(PROJ.name, PROJ.version) do |pkg|
+    pkg.need_tar = PROJ.gem.need_tar
+    pkg.need_zip = PROJ.gem.need_zip
+    pkg.package_files += PROJ.gem.spec.files
+  end
+  Rake::Task['gem:package'].instance_variable_set(:@full_comment, nil)
+
+  gem_file = if PROJ.gem.spec.platform == Gem::Platform::RUBY
+      "#{pkg.package_name}.gem"
+    else
+      "#{pkg.package_name}-#{PROJ.gem.spec.platform}.gem"
+    end
+
+  desc "Build the gem file #{gem_file}"
+  task :package => "#{pkg.package_dir}/#{gem_file}"
+
+  file "#{pkg.package_dir}/#{gem_file}" => [pkg.package_dir] + PROJ.gem.spec.files do
+    when_writing("Creating GEM") {
+      Gem::Builder.new(PROJ.gem.spec).build
+      verbose(true) {
+        mv gem_file, "#{pkg.package_dir}/#{gem_file}"
+      }
+    }
+  end
+
+  desc 'Install the gem'
+  task :install => [:clobber, :package] do
+    sh "#{SUDO} #{GEM} install pkg/#{PROJ.gem.spec.full_name}"
+  end
+
+  desc 'Uninstall the gem'
+  task :uninstall do
+    installed_list = Gem.source_index.find_name(PROJ.name)
+    if installed_list and installed_list.collect { |s| s.version.to_s}.include?(PROJ.version) then
+      sh "#{SUDO} #{GEM} uninstall -v '#{PROJ.version}' -i -x #{PROJ.name}"
+    end
+  end
+
+  desc 'Reinstall the gem'
+  task :reinstall => [:uninstall, :install]
+
+end  # namespace :gem
+
+desc 'Alias to gem:package'
+task :gem => 'gem:package'
+
+task :clobber => 'gem:clobber_package'
+
+remove_desc_for_task %w(gem:clobber_package)
+
+# EOF