yell 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+pkg/*
+*.gem
+.bundle
+.idea
+
+# bundler
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in yell.gemspec
+gemspec
+
+
+group :development do
+  gem "rake"
+
+  gem "rspec", "~> 2"
+  gem "timecop"
+end

data/Rakefile

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift( 'lib' )
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# === RSpec
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-fs --color)
+end
+
+task :default => :spec
+
+
+# === Rdoc
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "inventory #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'yell'

data/lib/yell/adapters/base.rb

@@ -0,0 +1,72 @@
+module Yell::Adapters
+  class Base
+
+    attr_reader :name # name of the logger this adapter belongs to
+
+    # Initialize a new base adapter. Other adapters should inherit from it.
+    def initialize ( options = {}, &block )
+      @block = block
+
+      @name = options[:name] || Yell.config.env
+      @level, @data = '', '' # default
+    end
+
+    def call ( level, msg )
+      reset!(true) if reset? # connect / get a file handle or whatever
+
+      @level, @message = level, msg
+
+      # self.instance_eval &@block if @block
+      @block.call( self ) if @block
+    end
+
+    def message
+      return @message if @message.is_a?( String )
+
+      @message.inspect
+    end
+
+    # Convenience method for resetting the processor.
+    #
+    # @param [true, false] now Perform the reset immediately? (default false)
+    def reset!( now = false )
+      close
+      open if now
+    end
+
+    # Opens the logfile or connection (in case of a database adapter)
+    def open
+      open! unless opened?
+    end
+
+    # Closes the file handle or connection (in case of a database adapter)
+    def close
+      close! unless closed?
+    end
+
+
+    private
+
+    def reset?; closed?; end
+
+    # stub
+    def open!
+      raise "Not implemented"
+    end
+
+    def opened?; false; end
+
+    # stub
+    def close!
+      raise "Not implemented"
+    end
+
+    def closed?; !opened?; end
+
+    # stub
+    def write
+      raise 'Not implemented'
+    end
+
+  end
+end

data/lib/yell/adapters/datefile.rb

@@ -0,0 +1,39 @@
+module Yell::Adapters
+  class Datefile < Yell::Adapters::File
+
+    DefaultDatePattern = "%Y%m%d"
+
+    def initialize ( options = {}, &block )
+      @date_pattern = options[:date_pattern] || DefaultDatePattern
+      @date = nil # default; do not override --R
+
+      @file_basename = options[:filename] || default_filename
+      options[:filename] = @file_basename
+
+      super( options, &block )
+    end
+
+    def reset!( now )
+      @filename = new_filename
+      super( now )
+    end
+
+
+    private
+
+    def reset?
+      _date = Time.now.strftime( @date_pattern )
+      unless opened? && _date == @date
+        @date = _date
+        return true
+      end
+
+      false
+    end
+
+    def new_filename
+      @file_basename.sub( /(\.\w+)?$/, ".#{@date}\\1" )
+    end
+
+  end
+end

data/lib/yell/adapters/file.rb

@@ -0,0 +1,95 @@
+module Yell::Adapters
+  class File < Yell::Adapters::Base
+
+    Colors = {
+      'DEBUG'   => "\e[32;1m",  # green;bold
+#        'INFO'    => "\e[0m",     # white
+      'WARN'    => "\e[33;1m",  # yello;bold
+      'ERROR'   => "\e[31;1m",  # red;bold
+      'FATAL'   => "\e[35;1m",  # magenta;bold
+      'UNKNOWN' => "\e[36m",    # cyan
+      'DEFAULT' => "\e[0m"      # NONE
+    }
+
+    def initialize ( options = {}, &block )
+      super
+
+      @formatter = formatter_from( options )
+
+      @colorize = options[:colorize]
+      @filename = options[:filename] || default_filename
+
+      @file_prefix, @file_suffix = options[:file_prefix], options[:file_suffix]
+
+      # validate the filename
+      unless @filename.is_a?( String )
+        raise( TypeError, "Argument :filename must be a string." )
+      end
+    end
+
+    def call ( level, msg )
+      super # Base call
+
+      msg = @formatter.format( @level, message )
+      msg = colorize( @level, msg ) if @colorize
+      msg << "\n" unless msg[-1] == ?\n # add new line if there is none
+
+      write( msg )
+    end
+
+
+    private
+
+    def write ( msg )
+      @file.print( msg )
+      @file.flush
+    rescue Exception => e
+      close # make sure the file gets closed
+      raise( e ) # re-raise the error
+    end
+
+    def close!
+      @file.close
+      @file = nil
+    end
+
+    def open!
+      # create directory if not exists
+      dirname = ::File.dirname( @filename )
+      FileUtils.mkdir_p( dirname ) unless ::File.directory?( dirname )
+
+      # open file for appending if exists, or create a new
+      filename = [ dirname, "#{@file_prefix}#{::File.basename(@filename)}#{@file_suffix}" ].join( '/' )
+      @file = ::File.open( filename, ::File::WRONLY|::File::APPEND|::File::CREAT )
+    end
+
+    def opened?; !@file.nil?; end
+
+    # Returns the right formatter from the given options
+    def formatter_from( options )
+      if options.key?(:formatter)
+        # this is done, so we can set :formatter => false to just output the given message
+        options[:formatter] || Yell::Formatter.new( "%m" )
+      elsif options[:formatter]
+        # the options :formatter was given
+        Yell::Formatter.new(
+          options[:formatter][:pattern],
+          options[:formatter][:date_pattern]
+        )
+      else
+        # Standard formatter
+        Yell::Formatter.new
+      end
+    end
+
+    def colorize( level, msg )
+      return msg unless color = Colors[level.upcase]
+      color + msg + Colors['DEFAULT']
+    end
+
+    def default_filename
+      "#{Yell.config.env}.log"
+    end
+
+  end
+end

data/lib/yell/adapters.rb

@@ -0,0 +1,19 @@
+module Yell
+  module Adapters
+
+    Dir[ ::File.dirname(__FILE__) + '/adapters/*.rb' ].each do |file|
+      autoload ::File.basename(file, '.rb').capitalize, file
+    end
+
+    # returns an instance of the given processor type
+    def self.new( type, options = {}, &block )
+      klass = case type
+        when String, Symbol then const_get( type.to_s.capitalize )
+        else type
+      end
+      
+      klass.new( options, &block )
+    end
+    
+  end
+end

data/lib/yell/config.rb

@@ -0,0 +1,53 @@
+module Yell
+  class Config
+  
+    def initialize( yaml_file = nil )
+      @yaml_file = yaml_file
+      
+      reload!
+    end
+    
+    def reload!; @options = nil; end
+    
+    def []( key ); options[key]; end
+    
+    def options
+      @options ||= begin
+        if yaml_file_defined?
+          require 'yaml'
+          require 'erb'
+
+          (YAML.load( ERB.new( File.read( yaml_file ) ).result ) || {})[ env ] || {}
+        else
+          {} # default
+        end
+      end
+    end
+
+    def env
+      ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'default'
+    end
+
+    def root
+      return ENV['RAILS_ROOT'] if ENV['RAILS_ROOT']
+      return RAILS_ROOT if defined?( RAILS_ROOT )
+
+      '.'
+    end
+    
+
+    private
+
+    def yaml_file_defined?
+      yaml_file && File.exist?( yaml_file )
+    end
+    
+    # Locates the yell.yml file. The file can end in .yml or .yaml,
+    # and be located in the current directory (eg. project root) or
+    # in a .config/ or config/ subdirectory of the current directory.
+    def yaml_file
+      @yaml_file || Dir.glob( "#{root}/{,.config/,config/}yell{.yml,.yaml}" ).first
+    end
+   
+  end   
+end

data/lib/yell/formatter.rb

@@ -0,0 +1,58 @@
+module Yell
+  class Formatter
+
+    PatternTable = {
+      "m" => "message", 
+      "d" => "date",
+      "l" => "level.downcase",
+      "L" => "level.upcase",
+      "p" => "$$", # pid
+      "h" => "hostname"
+    }
+    PatternRegexp = /([^%]*)(%\d*)?([dlLphm])?(.*)/
+    
+    DefaultPattern = "%d [%5L] %p %h: %m"
+    DefaultDatePattern = "%Y-%m-%d %H:%M:%S" # ISO8601
+
+    
+    def initialize ( pattern = nil, date_pattern = nil )
+      @pattern = pattern || DefaultPattern
+      @date_pattern = date_pattern || DefaultDatePattern
+      
+      define_format_method
+    end
+    
+
+    private
+
+    def define_format_method
+      buff, args, _pattern = "", [], @pattern.dup
+      
+      while true
+        match = PatternRegexp.match( _pattern )
+
+        buff << match[1] unless match[1].empty? 
+        break if match[2].nil?
+
+        buff << match[2] + 's' # '%s'
+        args << PatternTable[ match[3] ]
+
+        _pattern = match[4]
+      end
+
+      instance_eval %-
+        def format ( level, message )
+          sprintf( "#{buff}", #{args.join(',')} )
+        end
+      -
+    end
+
+    def date; Time.now.strftime( @date_pattern ); end
+    
+    def hostname
+      return @hostname if defined?( @hostname )
+      @hostname = Socket.gethostname rescue nil
+    end
+
+  end
+end

data/lib/yell/logger.rb

@@ -0,0 +1,82 @@
+module Yell
+  class Logger
+    Levels = [ 'debug', 'info', 'warn', 'error', 'fatal', 'unknown' ]
+
+    
+    def initialize( *args, &block )
+      @adapters = []
+
+      # extract options
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+
+      # check if filename was given as argument and put it into the @options
+      if args.last.is_a?( String )
+        @options[:filename] = args.pop unless @options[:filename]
+      end
+
+      @default_adapter = args.last.is_a?( Symbol ) ? args.pop : :file
+
+      # eval the given block if any
+      instance_eval( &block ) if block
+
+      build
+    end
+
+    # === the following methods are used for the logger setup
+    def adapter ( type, options = {}, &block )
+      @adapters << Yell::Adapters.new( type, @options.merge(options), &block )
+    rescue LoadError => e
+
+    end
+
+    def level ( val )
+      @level = case val
+        when Integer then val
+        when String, Symbol then Levels.index( val.to_s )
+        else nil
+      end
+    end
+
+    # Convenience method for resetting all adapters of the Logger.
+    #
+    # @param [true, false] now Perform the reset immediately? (default false)
+    def reset!( now = false )
+      close
+      open if now
+    end
+
+    def close; @adapters.each(&:close); end
+    def open; @adapters.each(&:open); end
+
+    
+    private
+
+    def build
+      adapter @default_adapter if @adapters.empty? # default adapter when none defined
+
+      define_log_methods
+    end
+
+    def define_log_methods
+      Levels.each_with_index do |name, index|
+        instance_eval %-
+          def #{name}?; #{@level.nil? || index >= @level}; end
+
+          def #{name} ( data = '' )
+            return unless #{name}?
+
+            data = yield if block_given?
+            process( "#{name}", data )
+
+            data
+          end
+        -
+      end
+    end
+
+    def process ( level, data )
+      @adapters.each { |a| a.call( level, data ) }
+    end
+
+  end
+end

data/lib/yell/version.rb

@@ -0,0 +1,4 @@
+module Yell
+  VERSION = "0.0.1"
+
+end

data/lib/yell.rb

@@ -0,0 +1,21 @@
+module Yell
+
+  autoload :Config,     File.dirname(__FILE__) + '/yell/config'
+  autoload :Formatter,  File.dirname(__FILE__) + '/yell/formatter'
+  autoload :Logger,     File.dirname(__FILE__) + '/yell/logger'
+  autoload :Adapters,   File.dirname(__FILE__) + '/yell/adapters'
+
+  # custom errors
+  class NoAdaptersDefined < StandardError; end
+  class NoSuchAdapter < StandardError; end
+
+
+  def self.new( *args, &block )
+    Yell::Logger.new( *args, &block )
+  end
+  
+  def self.config
+    @@config ||= Yell::Config.new
+  end
+
+end

data/yell.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yell/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yell"
+  s.version     = Yell::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Rudolf Schmidt"]
+  
+  s.homepage    = "http://rubygems.org/gems/yell"
+  s.summary     = %q{Logging library to log into files and databases}
+  s.description = %q{Logging library to log into files and databases}
+
+  s.rubyforge_project = "d_log"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: yell
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rudolf Schmidt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-23 00:00:00.000000000Z
+dependencies: []
+description: Logging library to log into files and databases
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- init.rb
+- lib/yell.rb
+- lib/yell/adapters.rb
+- lib/yell/adapters/base.rb
+- lib/yell/adapters/datefile.rb
+- lib/yell/adapters/file.rb
+- lib/yell/config.rb
+- lib/yell/formatter.rb
+- lib/yell/logger.rb
+- lib/yell/version.rb
+- yell.gemspec
+homepage: http://rubygems.org/gems/yell
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: d_log
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Logging library to log into files and databases
+test_files: []