bio-logger 0.6.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+  gem "bio", ">= 1.4.1"
+end

data/Gemfile.lock

@@ -0,0 +1,22 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bio (1.4.1)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bio (>= 1.4.1)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Pjotr Prins
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,174 @@
+= bio-logger
+
+This is a plugin for nailing down problems with big data parsers,
+common in bioinformatics, and sane handling of errors and exceptions in different
+situations (log-act). A logger can be made to behave differently as
+
+* NormalUser
+* Developer (or FailOnError)
+* WebServer
+* FaultTolerant systems
+
+One example of the use of having different behaviours, is when a program logs a
+warning to stdout as a user, but raises an exception as a developer.
+In Bioinformatics this is a common scenario when dealing with parsers.
+Large data files sometimes contain errors. As a user you want to
+continue and hope for the best (logging the error). As a developer you
+want to see how you can fix the problem. Waiting for a full run and
+checking the logs is tedious. The logger can be helpful here, and
+avoids sticking 'temporary' solutions in code.
+
+bio-logger builds up on log4r functionality, which comes with multiple
+handlers, such as a rotating and remote logging, and is thread-safe.
+Next to adding behaviours, bio-logger introduces a more fine-grained
+approach for logging errors. I.e. within 'debug', 'info', 'warn',
+'error' and 'fatal', an additional value 1..9 can be set to limit
+output and logging. This, again, can be helpful when dealing with huge
+log files. Switch a not so important and validated DEBUG, INFO or
+WARN, to a higher sub level will take it out of the logs. This can
+also make sense when deploying applications under different scenarios.
+
+Log4r is useful, compared to the standard Ruby logger,
+because it allows you to set reporting leaves by log type. I.e. if
+everything in BioRuby works, except for the BLAST parser, or some
+plugin, the logger
+can be tuned only to log BLAST debug level, and everything else at
+normal level.
+
+In other words, bio-logger helps in tracking down problems and
+provide a way of avoiding sprinkling $stderr.print statements through
+the code base.
+
+To support applications, bio-logger can also parse command line switches:
+
+add (multiple) loggers:
+
+  --logger stderr              Add stderr logger
+  --logger filen               Add filename logger
+
+specify global log level:
+
+  --trace  debug               Show all messages 
+  --trace  warn                Show messages more serious than 'warn'
+  --trace  warn:3              Show messaged more serious that 'warn' level 3
+
+overrides:
+
+  --trace  gff3:info:5         Override level for 'gff3' to info level 5
+  --trace  blast:debug         Override level for 'blast'
+  --trace  blast,gff3:debug    Override level for 'blast' and 'gff3' 
+  --trace  stderr:blast:debug  Override level for 'blast' on stderr 
+
+Earlier described behaviour, or 'acting', can be changed. This
+normally happens through library calls. There is one command line
+switch, which changes log-act:
+
+  --log-act FailOnError          Modify the logger for development
+
+which will cause, for example, 'error' and 'fatal' to fail during
+development, for special calls to the logger (described below).
+New behaviour can be implemented by deriving from an existing class.
+
+== Install bio-logger
+
+  gem install bio-logger
+
+== Bio::Log API
+
+In code there are more options. For example, it is possible to define
+multiple output streams, or split out different loggers to different
+streams. It is also possible to change behaviours by module.
+
+  require 'bio-logger'
+  include Bio::Log
+
+  # ==== Create loggers
+  log = LoggerPlus.new 'mylog'
+  log.outputters = Outputter.stderr
+
+  # create a second rotating log for BLAST
+  config = {
+    "filename" => "log/blast.log",  # make sure the dir exists!
+    "maxsize" => 16000,             # max file size
+    "trunc" => false                # don't delete log
+  }
+  log2 = LoggerPlus.new 'blast'
+  log2.outputters = RollingFileOutputter.new("blast", config)
+
+  # ==== Output messages on 'mylog'
+  log.debug "This is a message with level DEBUG"
+  log.info "This is a message with level INFO"
+  log.warn "This is a message with level WARN"
+  log.error "This is a message with level ERROR"
+  log.fatal "This is a message with level FATAL"
+  log.warn3 "This is a message with level WARN:3"
+
+  # Restrict output to WARN:3
+  log.level = WARN
+  log.sub_level = 3
+  log.info("This is a message with level INFO")      # not logged
+  log.warn8("This is a message with level WARN:8")   # not logged
+  log.warn1("This is a message with level WARN:1")   # logged
+  log.warn("This is a message with level WARN")      # logged
+
+  # Fetch the BLAST logger (assuming it exists)
+  blastlog = LoggerPlus['blast']
+  blastlog.warn("This is a message with level WARN") # logged
+
+  # Special logging behaviour
+  blastlog.error_("ERROR should not fail",:act => NormalUser.new)
+  dev = FailOnError.new
+  blastlog.info_("INFO should not fail",:act => dev)
+  blastlog.error_("As Developer ERROR should fail",:act => dev)
+
+For parsing command line options with the OptionParser:
+
+  opts.on("--logger filename",String,"Log to file (default STDOUT)") do | name |
+    Bio::Log::CLI.logger(name)
+  end
+
+  opts.on("--trace options",String,"Set log level (default INFO, see bio-logger)") do | s |
+    Bio::Log::CLI.trace(s)
+  end
+
+  opts.on("-q", "--quiet", "Run quietly") do |q|
+    Bio::Log::CLI.trace('error')
+  end
+
+  opts.on("-v", "--verbose", "Run verbosely") do |v|
+    Bio::Log::CLI.trace('info')
+  end
+
+  # Realize settings
+  Bio::Log::CLI.configure('mylog')
+
+== Documentation
+
+The log4r documentation and source code can be used, as this Logger 
+implementation passes everything down, except for the added methods.
+
+See http://log4r.rubyforge.org/
+
+See also the Specs in ./spec for more examples. Run the Specs with
+
+  rspec spec/*.rb
+
+== TODO
+
+The current version is used in BioRuby parser plugins (e.g.
+http://github.com/pjotrp/bioruby-gff3-plugin/). 
+
+It may be
+interesting to run loggers as actors, so the are fully parallelized
+with the main application.
+
+== Cite
+
+If you use this software, please cite http://dx.doi.org/10.1093/bioinformatics/btq475
+
+== Copyright
+
+Copyright (C) 2011 Pjotr Prins <pjotr.prins@thebird.nl> 
+
+See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "bio-logger"
+  gem.homepage = "http://github.com/pjotrp/bioruby-logger"
+  gem.license = "MIT"
+  gem.summary = %Q{Log4r wrapper for BioRuby}
+  gem.description = %Q{Log4r wrapper for BioRuby}
+  gem.email = "pjotr.public01@thebird.nl"
+  gem.authors = ["Pjotr Prins"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  gem.add_runtime_dependency 'log4r', '> 1.1.6'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bio-logger #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.6.0

data/bio-logger.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bio-logger}
+  s.version = "0.6.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pjotr Prins"]
+  s.date = %q{2011-01-12}
+  s.description = %q{Log4r wrapper for BioRuby}
+  s.email = %q{pjotr.public01@thebird.nl}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bio-logger.gemspec",
+    "lib/bio-logger.rb",
+    "lib/bio/log/logger.rb",
+    "lib/bio/log/loggercli.rb",
+    "lib/bio/log/loggersublevels.rb",
+    "lib/bio/log/loggerusers.rb",
+    "spec/biologger_cli_spec.rb",
+    "spec/biologger_spec.rb",
+    "test/helper.rb",
+    "test/test_bio-logger.rb"
+  ]
+  s.homepage = %q{http://github.com/pjotrp/bioruby-logger}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Log4r wrapper for BioRuby}
+  s.test_files = [
+    "spec/biologger_cli_spec.rb",
+    "spec/biologger_spec.rb",
+    "test/helper.rb",
+    "test/test_bio-logger.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<bio>, [">= 1.4.1"])
+      s.add_runtime_dependency(%q<log4r>, ["> 1.1.6"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<bio>, [">= 1.4.1"])
+      s.add_dependency(%q<log4r>, ["> 1.1.6"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<bio>, [">= 1.4.1"])
+    s.add_dependency(%q<log4r>, ["> 1.1.6"])
+  end
+end
+

data/lib/bio-logger.rb

@@ -0,0 +1,12 @@
+
+require "rubygems"
+begin
+  gem "log4r" , "> 1.1.8"
+rescue
+	$stderr.print "log4r not installed, bailing out...\n"
+  exit 1
+end
+
+require 'log4r'
+require 'bio/log/logger'
+require 'bio/log/loggercli'

data/lib/bio/log/logger.rb

@@ -0,0 +1,60 @@
+
+require 'bio/log/loggersublevels'
+require 'bio/log/loggerusers'
+require 'bio/log/loggercli'
+
+module Bio
+
+  module Log
+
+    include Log4r
+
+    # Derived from the Log4r Logger class
+    class LoggerPlus < Logger
+      include LoggerSubLevels
+
+      def debug_ msg, options = {}
+        if options[:act]
+          options[:act].debug(self,msg)
+        else
+          debug msg
+        end
+      end
+
+      def info_ msg, options = {}
+        if options[:act]
+          options[:act].info(self,msg)
+        else
+          info msg
+        end
+      end
+
+      def warn_ msg, options = {}
+        if options[:act]
+          options[:act].warn(self,msg)
+        else
+          warn msg
+        end
+      end
+
+      def error_ msg, options = {}
+        if options[:act]
+          options[:act].error(self,msg)
+        else
+          error msg
+        end
+      end
+
+      def fatal_ msg, options = {}
+        if options[:act]
+          options[:act].fatal(self,msg)
+        else
+          fatal msg
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/bio/log/loggercli.rb

@@ -0,0 +1,95 @@
+require 'singleton'
+
+module Bio
+  module Log
+
+    class LoggerPlusGlobal
+      include Singleton
+
+      attr_accessor :outputter_type, :trace
+
+    end
+
+    module CLI
+
+      # Parse and store global logger type
+      def CLI::logger name
+        LoggerPlusGlobal.instance.outputter_type = case name
+          when 'stderr' then :stderr
+          when 'stdout' then :stdout
+          else 
+            {:file => { :filename => name }}
+        end
+      end
+
+      # Parse and store trace options
+      def CLI::trace s
+        sub_level = nil
+
+        opts = {}
+        a = s.split(':')
+        if a.last =~ /^\d+$/
+          sub_level = a.pop.to_i
+        end
+        level = a.pop.downcase
+        outputter = 
+          if a.size == 2 
+            a.shift
+          end
+        if a.size == 0
+          a = [:default] 
+        else
+          a = a[0].split(',')
+        end
+        a.each do | type |
+          opts[type] = { :level => level, :sub_level => sub_level }
+          opts[type][:outputter_name] = outputter if outputter
+        end
+        LoggerPlusGlobal.instance.trace ||= {}
+        LoggerPlusGlobal.instance.trace = LoggerPlusGlobal.instance.trace.merge(opts)
+      end
+
+      def CLI::configure logname = nil
+        include Bio::Log
+
+        type = LoggerPlusGlobal.instance.outputter_type
+        trace = LoggerPlusGlobal.instance.trace
+        trace ||= {}
+        default = {}
+        default = trace[:default] if trace[:default]
+        trace[logname] ||= {} if logname
+        trace.each do | name, opts |
+          next if name == :default
+          logger_type = type
+          logger_type = default[:outputter_name] if default[:outputter_name]
+          logger_type = opts[:outputter_name] if opts[:outputter_name]
+          logger = LoggerPlus[name]
+          raise "Unknown logger <#{name}>" if logger == nil
+          logger.outputters = 
+            case logger_type
+              when 'stderr', :stderr then logger.outputters = Outputter.stderr
+              when nil, 'stdout', :stdout then logger.outputters = Outputter.stdout
+              else 
+                # p [name, logger_type]
+                FileOutputter.new(name, logger_type[:file])
+            end
+          set_levels(logger, default) if default
+          set_levels(logger, opts)
+        end
+      end
+
+      private
+
+      def CLI::set_levels logger, opts
+        logger.level = case opts[:level]
+          when 'debug' then DEBUG
+          when 'info' then INFO
+          when 'warn' then WARN
+          when 'error' then ERROR
+          when 'fatal' then FATAL
+        end if opts[:level]
+        logger.sub_level = opts[:sub_level] if opts[:sub_level]
+      end
+    end
+  end
+end

data/lib/bio/log/loggersublevels.rb

@@ -0,0 +1,153 @@
+
+module Bio
+  module Log
+
+    # Support for numbered sub-levels. We could have used
+    # method_missing, or something similar, but this rather
+    # clean.
+    module LoggerSubLevels
+      attr_accessor :sub_level
+
+      def debug1(s)
+        debug(s) if !sub_level or sub_level >= 1
+      end
+      def debug2(s)
+        debug(s) if !sub_level or sub_level >= 2
+      end
+      def debug3(s)
+        debug(s) if !sub_level or sub_level >= 3
+      end
+      def debug4(s)
+        debug(s) if !sub_level or sub_level >= 4
+      end
+      def debug5(s)
+        debug(s) if !sub_level or sub_level >= 5
+      end
+      def debug6(s)
+        debug(s) if !sub_level or sub_level >= 6
+      end
+      def debug7(s)
+        debug(s) if !sub_level or sub_level >= 7
+      end
+      def debug8(s)
+        debug(s) if !sub_level or sub_level >= 8
+      end
+      def debug9(s)
+        debug(s) if !sub_level or sub_level >= 9
+      end
+
+      def info1(s)
+        info(s) if !sub_level or sub_level >= 1
+      end
+      def info2(s)
+        info(s) if !sub_level or sub_level >= 2
+      end
+      def info3(s)
+        info(s) if !sub_level or sub_level >= 3
+      end
+      def info4(s)
+        info(s) if !sub_level or sub_level >= 4
+      end
+      def info5(s)
+        info(s) if !sub_level or sub_level >= 5
+      end
+      def info6(s)
+        info(s) if !sub_level or sub_level >= 6
+      end
+      def info7(s)
+        info(s) if !sub_level or sub_level >= 7
+      end
+      def info8(s)
+        info(s) if !sub_level or sub_level >= 8
+      end
+      def info9(s)
+        info(s) if !sub_level or sub_level >= 9
+      end
+
+      def warn1(s)
+        warn(s) if !sub_level or sub_level >= 1
+      end
+      def warn2(s)
+        warn(s) if !sub_level or sub_level >= 2
+      end
+      def warn3(s)
+        warn(s) if !sub_level or sub_level >= 3
+      end
+      def warn4(s)
+        warn(s) if !sub_level or sub_level >= 4
+      end
+      def warn5(s)
+        warn(s) if !sub_level or sub_level >= 5
+      end
+      def warn6(s)
+        warn(s) if !sub_level or sub_level >= 6
+      end
+      def warn7(s)
+        warn(s) if !sub_level or sub_level >= 7
+      end
+      def warn8(s)
+        warn(s) if !sub_level or sub_level >= 8
+      end
+      def warn9(s)
+        warn(s) if !sub_level or sub_level >= 9
+      end
+
+      def error1(s)
+        error(s) if !sub_level or sub_level >= 1
+      end
+      def error2(s)
+        error(s) if !sub_level or sub_level >= 2
+      end
+      def error3(s)
+        error(s) if !sub_level or sub_level >= 3
+      end
+      def error4(s)
+        error(s) if !sub_level or sub_level >= 4
+      end
+      def error5(s)
+        error(s) if !sub_level or sub_level >= 5
+      end
+      def error6(s)
+        error(s) if !sub_level or sub_level >= 6
+      end
+      def error7(s)
+        error(s) if !sub_level or sub_level >= 7
+      end
+      def error8(s)
+        error(s) if !sub_level or sub_level >= 8
+      end
+      def error9(s)
+        error(s) if !sub_level or sub_level >= 9
+      end
+
+      def fatal1(s)
+        fatal(s) if !sub_level or sub_level >= 1
+      end
+      def fatal2(s)
+        fatal(s) if !sub_level or sub_level >= 2
+      end
+      def fatal3(s)
+        fatal(s) if !sub_level or sub_level >= 3
+      end
+      def fatal4(s)
+        fatal(s) if !sub_level or sub_level >= 4
+      end
+      def fatal5(s)
+        fatal(s) if !sub_level or sub_level >= 5
+      end
+      def fatal6(s)
+        fatal(s) if !sub_level or sub_level >= 6
+      end
+      def fatal7(s)
+        fatal(s) if !sub_level or sub_level >= 7
+      end
+      def fatal8(s)
+        fatal(s) if !sub_level or sub_level >= 8
+      end
+      def fatal9(s)
+        fatal(s) if !sub_level or sub_level >= 9
+      end
+
+    end
+  end
+end

data/lib/bio/log/loggerusers.rb

@@ -0,0 +1,48 @@
+
+module Bio
+
+  module Log
+
+    # NormalUser logs, but does not fail
+    class NormalUser
+      # include LoggerSubLevels
+
+      def debug logger,msg
+        logger.debug msg
+      end
+      def info logger,msg
+        logger.info msg
+      end
+      def warn logger,msg
+        logger.warn msg
+      end
+      def error logger,msg
+        logger.error msg
+      end
+      def fatal logger,msg
+        logger.fatal msg
+      end
+    end
+
+    class FailOnErrorException < RuntimeError
+    end
+
+    class FailOnError < NormalUser
+      def error logger, msg
+        logger.error msg
+        raise FailOnErrorException
+      end
+
+      def fatal logger, msg
+        logger.fatal msg
+        raise FailOnErrorException
+      end
+    end
+
+    # Developer acts so that errors raise an exception.
+    class Developer < FailOnError
+    end
+
+  end
+
+end

data/spec/biologger_cli_spec.rb

@@ -0,0 +1,78 @@
+# RSpec for bio-logger plugin. Run with something like:
+#
+#   rspec logger_spec.rb 
+#
+# Copyright (C) 2011 Pjotr Prins <pjotr.prins@thebird.nl>
+#
+
+$: << "../lib"
+
+require 'bio-logger'
+include Bio::Log
+
+describe Bio::Log::CLI, "bio-logger command line parsing" do
+
+  before(:all) do
+    # @mylog = Bio::Log::LoggerPlus.root
+    @mylog = LoggerPlus.new 'mylog'
+    @mylog.outputters = Outputter.stderr
+    @global = LoggerPlusGlobal.instance
+  end
+
+  before(:each) do
+    LoggerPlusGlobal.instance.trace = {}
+    LoggerPlusGlobal.instance.outputter_type = :stdout
+  end
+  it "should parse --logger stderr and set the global" do
+    CLI.logger("stderr")
+    LoggerPlusGlobal.instance.outputter_type.should == :stderr
+  end
+  it "should parse --logger filen to set filename logger" do
+    CLI.logger("test.log")
+    @global.outputter_type[:file].should == {:filename => 'test.log'}
+  end
+  it "should parse --trace  debug to show all messages" do
+    CLI.trace("debug")
+    @global.trace[:default].should == { :level => 'debug', :sub_level => nil } 
+  end
+  it "should parse --trace  warn to show how messages more serious than 'warn'" do
+    CLI.trace("warn")
+    @global.trace[:default].should == { :level => 'warn', :sub_level => nil } 
+  end
+  it "should parse --trace  warn:3 to show messaged more serious that 'warn' level 3" do
+    CLI.trace("warn:3")
+    @global.trace[:default].should == { :level => 'warn', :sub_level => 3 } 
+  end
+  it "should parse --trace  blast:debug to override level for 'blast'" do
+    CLI.trace("blast:debug")
+    @global.trace.should == {"blast"=>{:level=>"debug", :sub_level=>nil}}
+  end
+  it "should parse --trace  gff3:info:5 to override level for 'gff3' to info level 5" do
+    CLI.trace("gff3:info:5")
+    @global.trace.should == {"gff3"=>{:level=>"info", :sub_level=>5}}
+  end
+  it "should parse --trace  blast,gff3:debug to override level for 'blast' and 'gff3'" do
+    CLI.trace("blast,gff3:debug:5")
+    @global.trace.should == {"blast"=>{:level=>"debug", :sub_level=>5}, "gff3"=>{:level=>"debug", :sub_level=>5}} 
+  end
+  it "should parse --trace  stderr:blast:debug to override level for 'blast' on stderr" do
+    CLI.trace("stderr:blast:debug")
+    @global.trace.should ==
+      {"blast"=>{:level=>"debug", :sub_level=>nil, :outputter_name=>"stderr"}}
+  end
+  it "should parse --trace  stderr:blast,gff3:debug:1 to override level for 'blast' on stderr" do
+    CLI.trace("stderr:blast,gff3:debug:1")
+    @global.trace.should ==
+      {"blast"=>{:level=>"debug", :sub_level=>1, :outputter_name=>"stderr"}, "gff3"=>{:level=>"debug", :sub_level=>1, :outputter_name=>"stderr"}}
+  end
+  it "should realize setting warn:3" do
+    CLI.trace("blast:warn:3")
+    LoggerPlus.new('blast')
+    CLI.configure
+    log = LoggerPlus['blast']
+    log.level.should == WARN
+    log.sub_level.should == 3
+  end
+end
+
+

data/spec/biologger_spec.rb

@@ -0,0 +1,100 @@
+# RSpec for bio-logger plugin. Run with something like:
+#
+#   rspec logger_spec.rb 
+#
+# Copyright (C) 2011 Pjotr Prins <pjotr.prins@thebird.nl>
+#
+
+$: << "../lib"
+
+require 'bio-logger'
+include Bio::Log
+
+  def logit mylog
+    mylog.debug "This is a message with level DEBUG"
+    mylog.info "This is a message with level INFO"
+    mylog.warn "This is a message with level WARN"
+    mylog.error "This is a message with level ERROR"
+    mylog.fatal "This is a message with level FATAL"
+  end
+
+
+describe Bio::Log, "logs" do
+
+  before(:all) do
+    # @mylog = Bio::Log::LoggerPlus.root
+    @mylog = LoggerPlus.new 'mylog'
+    @mylog.outputters = Outputter.stderr
+    logit @mylog
+    blastlog = LoggerPlus.new 'blast'
+    blastlog.outputters = Outputter.stderr
+  end
+
+  after(:all) do
+    File.unlink("file.log")
+    File.unlink("TestSize000001.log")
+  end
+
+  it "should have a stderr logger" do
+    # logit @mylog
+    @mylog.info("This is a message with level INFO").should_not == nil
+  end
+
+  it "should have a rotating file logger" do
+    config = {
+      "filename" => "TestSize.log",
+      "maxsize" => 16000,
+      "trunc" => true
+    }
+    log2 = LoggerPlus.new 'mylog2'
+    log2.outputters = RollingFileOutputter.new("mylog2", config)
+    log2.info("This is a message with level INFO").should_not == nil
+  end
+  it "should have a file logger" do
+    log3 = LoggerPlus.new 'filelog'
+    log3.outputters = FileOutputter.new('filelog', :filename => 'file.log',:trunc => false)
+    log3.info("This is a message with level INFO").should_not == nil
+    File.read('file.log').should == " INFO filelog: This is a message with level INFO\n"
+  end
+  it "should set global loglevel to warn" do
+    # @mylog.level = Bio::Log::WARN
+    @mylog.level = WARN
+    # logit @mylog
+    @mylog.info("This is a message with level INFO").should == nil
+    @mylog.error("This is a message with level ERROR").should_not == nil
+    @mylog.level = DEBUG
+  end
+  it "should set global loglevel with WARN:3" do
+    @mylog.level = WARN
+    @mylog.sub_level = 3
+    @mylog.info("This is a message with level INFO").should == nil
+    @mylog.warn8("This is a message with level WARN:8").should == nil
+    @mylog.warn1("This is a message with level WARN:1").should_not == nil
+    @mylog.warn("This is a message with level WARN").should_not == nil
+    @mylog.error("This is a message with level ERROR").should_not == nil
+    @mylog.level = DEBUG
+    @mylog.sub_level = nil
+    @mylog.info("This is a message with level INFO").should_not == nil
+    @mylog.warn8("This is a message with level WARN:8").should_not == nil
+  end
+  it "should override level for 'blast' to info level 5" do
+    log = LoggerPlus['blast']
+    log.should_not == nil
+    log.info("This is a message with level INFO").should_not == nil
+    log.level = INFO
+    log.sub_level = 5
+    log.info("This is a message with level INFO").should_not == nil
+    log.info5("This is a message with level INFO:5").should_not == nil
+    log.info6("This is a message with level INFO:6").should == nil
+  end
+  it "should modify the logger for development" do
+    @mylog.error_("ERROR should not fail",:act => NormalUser.new).should_not == nil
+    dev = Developer.new
+    @mylog.info_("INFO should not fail",:act => dev).should_not == nil
+    lambda { @mylog.error_("As Developer ERROR should fail",:act => dev) }.should raise_error
+    lambda { @mylog.fatal_("As Developer FATAL should fail",:act => dev) }.should raise_error
+
+  end
+end
+
+

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bio-logger'
+
+class Test::Unit::TestCase
+end

data/test/test_bio-logger.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestBioLogger < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification 
+name: bio-logger
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
+platform: ruby
+authors: 
+- Pjotr Prins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-12 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: bio
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 6
+        version: 1.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *id006
+description: Log4r wrapper for BioRuby
+email: pjotr.public01@thebird.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bio-logger.gemspec
+- lib/bio-logger.rb
+- lib/bio/log/logger.rb
+- lib/bio/log/loggercli.rb
+- lib/bio/log/loggersublevels.rb
+- lib/bio/log/loggerusers.rb
+- spec/biologger_cli_spec.rb
+- spec/biologger_spec.rb
+- test/helper.rb
+- test/test_bio-logger.rb
+has_rdoc: true
+homepage: http://github.com/pjotrp/bioruby-logger
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -784249939
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Log4r wrapper for BioRuby
+test_files: 
+- spec/biologger_cli_spec.rb
+- spec/biologger_spec.rb
+- test/helper.rb
+- test/test_bio-logger.rb