hatchet 0.0.2 → 0.0.3

data/lib/hatchet/level_manager.rb

@@ -11,9 +11,20 @@ module Hatchet
     #
     LEVELS = [:debug, :info, :warn, :error, :fatal, :off]
 
-    # Public: The Hash containing the log level configuration.
+    # Public: Returns the Hash containing the log level configuration.
     #
-    attr_accessor :levels
+    def levels
+      @levels ||= {}
+    end
+
+    # Public: Sets the Hash containing the log level configuration.
+    #
+    # levels - The Hash to use as the log level configuration.
+    #
+    # Returns nothing.
+    def levels=(levels)
+      @levels = levels
+    end
 
     # Public: Set the lowest level of message to log for the given context.
     #

data/lib/hatchet/logger.rb

@@ -5,14 +5,13 @@ module Hatchet
   # Internal: Class that handles logging calls and distributes them to all its
   # appenders.
   #
-  # Each logger has 6 methods. Those are, in decreasing order of severity:
+  # Each logger has 5 methods. Those are, in decreasing order of severity:
   #
   #  * fatal
   #  * error
   #  * warn
   #  * info
   #  * debug
-  #  * trace
   #
   # All the methods have the same signature. You can either provide a message as
   # a direct string, or as a block to the method is lazily evaluated (this is
@@ -38,21 +37,30 @@ module Hatchet
       @appenders = appenders
     end
 
-    # Public: Logs a message at the given level.
-    #
-    # message - An already evaluated message, usually a String (default: nil).
-    # block   - An optional block which will provide a message when invoked.
-    #
-    # One of message or block must be provided. If both are provided then the
-    # block is preferred as it is assumed to provide more detail.
-    #
-    # Returns nothing.
-    #
-    [:trace, :debug, :info, :warn, :error, :fatal].each do |level|
+    [:debug, :info, :warn, :error, :fatal].each do |level|
+
+      # Public: Logs a message at the given level.
+      #
+      # message - An already evaluated message, usually a String (default: nil).
+      # block   - An optional block which will provide a message when invoked.
+      #
+      # One of message or block must be provided. If both are provided then the
+      # block is preferred as it is assumed to provide more detail.
+      #
+      # Returns nothing.
+      #
       define_method level do |message = nil, &block|
         return unless message or block
         add level, Message.new(message, &block)
       end
+
+      # Public: Returns true if any of the appenders will log messages for the
+      # current context, otherwise returns false.
+      #
+      define_method "#{level}?" do
+        @appenders.any? { |appender| appender.enabled? level, @context }
+      end
+
     end
 
     private
@@ -67,7 +75,6 @@ module Hatchet
     #             * warn
     #             * info
     #             * debug
-    #             * trace
     #
     # message - The message that will be logged by an appender when it is
     #           configured to log at the given level or lower.

data/lib/hatchet/standard_formatter.rb

@@ -15,7 +15,7 @@ module Hatchet
     # Returns the context and message separated by a hypen.
     #
     def format(level, context, message)
-      "#{timestamp} [#{thread_name}] #{level.to_s.upcase.ljust 5} #{message}"
+      "#{timestamp} [#{thread_name}] #{format_level level} #{context} - #{message}"
     end
 
     private
@@ -37,6 +37,12 @@ module Hatchet
       end
     end
 
+    # Private: Returns the level formatted for log output as a String.
+    #
+    def format_level(level)
+      level.to_s.upcase.ljust(5)
+    end
+
   end
 
 end

data/lib/hatchet/version.rb

@@ -4,6 +4,6 @@ module Hatchet
 
   # Public: The version of Hatchet.
   #
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 
 end

data/spec/configuration_spec.rb

@@ -0,0 +1,94 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'spec_helper'
+
+describe 'configuration' do
+  describe 'appender defaults' do
+    let(:set_levels) { { unique: :fake_level } }
+    let(:appender)   { StoringAppender.new }
+
+    before do
+      Hatchet.configure do |config|
+        config.levels = set_levels
+        config.appenders << appender
+      end
+    end
+
+    it 'global levels when not explicitly set' do
+      assert set_levels == appender.levels
+    end
+
+    it 'formatter set as a StandardFormatter' do
+      assert appender.formatter.instance_of? StandardFormatter
+    end
+  end
+
+  describe 'appender overrides' do
+    let(:default_levels)     { { unique: :fake_level } }
+    let(:appender_levels)    { { appender: :faker_level } }
+    let(:appender_formatter) { SimpleFormatter.new }
+    let(:appender) do
+      StoringAppender.new do |app|
+        app.levels    = appender_levels
+        app.formatter = appender_formatter
+      end
+    end
+
+    before do
+      Hatchet.configure do |config|
+        config.levels = default_levels
+        config.appenders << appender
+      end
+    end
+
+    it 'keeps the levels assigned to the appender' do
+      assert appender.levels == appender_levels
+    end
+
+    it 'keeps the formatter assigned to the appender' do
+      assert appender.formatter == appender_formatter
+    end
+  end
+
+  describe 'global default level' do
+    let(:appender)   { StoringAppender.new }
+
+    before do
+      Hatchet.configure do |config|
+        config.appenders << appender
+      end
+    end
+
+    it 'set to info' do
+      assert appender.levels[nil] == :info
+    end
+  end
+
+  describe 'everything wires up' do
+    let(:appender) { StoringAppender.new }
+
+    before do
+      Hatchet.configure do |config|
+        config.appenders << appender
+      end
+    end
+
+    class Example
+      include Hatchet
+
+      def initialize
+        log.info { 'Creating instance' }
+      end
+    end
+
+    it 'should log a message when creating an instance' do
+      Example.new
+      msg = appender.messages.last
+
+      assert_equal :info,   msg.level
+      assert_equal Example, msg.context
+      assert_equal 'Creating instance', msg.message.to_s
+    end
+  end
+end
+

data/spec/helpers/logger_double.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+require 'ostruct'
+
+class LoggerDouble
+  attr_accessor :level
+  attr_accessor :formatter
+  attr_reader :messages
+
+  def initialize
+    @messages = []
+  end
+
+  [:debug, :info, :warn, :error, :fatal].each do |level|
+    define_method level do |message|
+      messages << OpenStruct.new(level: level, message: message)
+    end
+  end
+end
+

data/spec/helpers/simple_formatter.rb

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+
+require 'ostruct'
+
+class SimpleFormatter
+  def format(level, context, message)
+    OpenStruct.new(level: level, context: context, message: message)
+  end
+end
+

data/spec/helpers/storing_appender.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+class StoringAppender
+  include LevelManager
+
+  attr_accessor :formatter
+
+  attr_reader :messages
+
+  def initialize(default_level = nil)
+    @messages = []
+    @levels = {}
+    @levels[nil] = default_level unless default_level.nil?
+    yield self if block_given?
+  end
+
+  def add(level, context, message)
+    @messages << OpenStruct.new(level: level, context: context, message: message)
+  end
+end
+

data/spec/level_manager_spec.rb

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'spec_helper'
+
+describe LevelManager do
+  before do
+    @manager = Object.new
+    @manager.extend LevelManager
+  end
+
+  describe 'setting a default level of info' do
+    before do
+      @manager.level :info
+    end
+
+    it 'has info messages enabled for any context' do
+      assert @manager.enabled?(:info, 'Foo::Bar')
+    end
+
+    it 'has debug messages disabled for any context' do
+      refute @manager.enabled?(:debug, 'Foo::Bar')
+    end
+
+    describe 'lowering the threshold for a specific context' do
+      before do
+        @manager.level :debug, 'Foo::Bar'
+      end
+
+      it 'has debug messages enabled for that context' do
+        assert @manager.enabled?(:debug, 'Foo::Bar')
+      end
+
+      it 'has debug messages enabled for a child context' do
+        assert @manager.enabled?(:debug, 'Foo::Bar::Baz')
+      end
+
+      it 'has debug message disabled for the parent context' do
+        refute @manager.enabled?(:debug, 'Foo')
+      end
+    end
+
+    describe 'raising the threshold for a specific context' do
+      before do
+        @manager.level :fatal, 'Foo::Bar'
+      end
+
+      it 'has info messages disabled for that context' do
+        refute @manager.enabled?(:info, 'Foo::Bar')
+      end
+
+      it 'has fatal message enabled for that context' do
+        assert @manager.enabled?(:fatal, 'Foo')
+      end
+
+      it 'has info messages disabled for a child context' do
+        refute @manager.enabled?(:info, 'Foo::Bar::Baz')
+      end
+
+      it 'has info message enabled for the parent context' do
+        assert @manager.enabled?(:info, 'Foo')
+      end
+    end
+  end
+end
+

data/spec/logger_appender_spec.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'spec_helper'
+
+describe LoggerAppender do
+  let(:logger)    { LoggerDouble.new }
+  let(:formatter) { SimpleFormatter.new }
+  let(:subject) do
+    LoggerAppender.new do |appender|
+      appender.logger    = logger
+      appender.formatter = formatter
+      appender.levels    = { nil => :info }
+    end
+  end
+
+  describe 'creating an appender' do
+    before { subject }
+
+    it 'removes filtering from the interal logger' do
+      assert_equal ::Logger::DEBUG, logger.level
+    end
+
+    it 'sets a formatter that returns the message with a trailing linebreak' do
+      msg = 'Plain message'
+      formatted_message = logger.formatter.call('sev', Time.now, 'prog', msg)
+      assert_equal "#{msg}\n", formatted_message
+    end
+  end
+
+  describe 'sending a message for a disabled level' do
+    it 'does not pass the message on to the logger' do
+      subject.add :debug, 'Context', 'Hello, World'
+      assert_empty logger.messages
+    end
+  end
+
+  describe 'sending a message of an enabled level' do
+    let(:message) { logger.messages.last }
+
+    it 'passes the message on to the logger' do
+      subject.add :info, 'Context', 'Hello, World'
+
+      assert :info,          message.level
+      assert 'Context',      message.context
+      assert 'Hello, World', message.message
+    end
+  end
+end
+

data/spec/logger_spec.rb

@@ -0,0 +1,105 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'spec_helper'
+
+describe Hatchet::Logger do
+  let(:appender)  { StoringAppender.new :debug }
+  let(:appenders) { [appender] }
+  let(:context)   { Context::Class.new }
+  let(:subject)   { Hatchet::Logger.new context, appenders }
+
+  ALL_LEVELS.each do |level|
+    describe "receiving #{level} messages" do
+      let(:message) { "#{level} message" }
+
+      it 'should store pre-evaluated messages' do
+        subject.send level, message
+        received = appender.messages.last
+
+        assert level == received.level
+        assert context.class == received.context
+        assert message == received.message.to_s
+      end
+
+      it 'should store block messages' do
+        subject.send(level) { message }
+        received = appender.messages.last
+
+        assert level == received.level
+        assert context.class == received.context
+        assert message == received.message.to_s
+      end
+    end
+  end
+
+  describe 'responding to level checks' do
+    let(:noop_appender) { StoringAppender.new :off }
+
+    before do
+      appenders << noop_appender
+    end
+
+    ALL_LEVELS.each do |level|
+      it "responds to #{level} as one of the appenders does" do
+        assert subject.send "#{level}?"
+      end
+    end
+
+    describe 'with no appenders responding to debug' do
+      before do
+        appenders.clear
+        appenders << StoringAppender.new(:info)
+        appenders << StoringAppender.new(:warn)
+      end
+
+      it 'does not respond to debug' do
+        refute subject.debug?
+      end
+
+      it 'does respond to info' do
+        assert subject.info?
+      end
+    end
+  end
+
+  describe 'empty messages' do
+    it 'not passed on to appender' do
+      subject.fatal
+
+      assert_empty appender.messages
+    end
+  end
+
+  describe 'naming context' do
+    let(:context_name) do
+      subject.fatal 'Message'
+      # Get the context passed to the appender.
+      appender.messages.last.context.to_s
+    end
+
+    describe 'for instances of a class' do
+      let(:context) { Context::Class.new }
+
+      it 'reports class name' do
+        assert_equal 'Context::Class', context_name
+      end
+    end
+
+    describe 'for modules' do
+      let(:context) { Context }
+
+      it 'reports module name' do
+        assert_equal 'Context', context_name
+      end
+    end
+
+    describe 'for the initial execution context of Ruby' do
+      let(:context) { INITIAL_EXECUTION_CONTEXT }
+
+      it 'reports "main"' do
+        assert_equal 'main', context_name
+      end
+    end
+  end
+end
+

data/spec/message_spec.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'spec_helper'
+
+describe Message do
+  describe 'providing an evaluted message' do
+    let(:subject) { Message.new 'Evaluated' }
+
+    it 'returns the given message' do
+      assert_equal 'Evaluated', subject.to_s
+    end
+  end
+
+  describe 'providing a block message' do
+    let(:subject) do
+      @evaluated = 0
+      Message.new do
+        @evaluated += 1
+        'Block'
+      end
+    end
+
+    it 'returns the result of evaluating the block' do
+      assert_equal 'Block', subject.to_s
+    end
+
+    it 'only evaluates the block once for multiple calls' do
+      subject.to_s
+      subject.to_s
+      assert_equal 1, @evaluated
+    end
+  end
+
+  describe 'providing both an evaluated and block message' do
+    let(:subject) do
+      Message.new 'Evaluated' do
+        'Block'
+      end
+    end
+
+    it 'returns the result of evaluating the block' do
+      assert_equal 'Block', subject.to_s
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require_relative '../lib/hatchet'
+
+# Avoid having to refer to everything absolutely all the time.
+include Hatchet
+
+require_relative 'helpers/logger_double'
+require_relative 'helpers/simple_formatter'
+require_relative 'helpers/storing_appender'
+
+INITIAL_EXECUTION_CONTEXT = self
+
+ALL_LEVELS = [:debug, :info, :warn, :error, :fatal]
+
+module Context
+  class Class ; end
+end
+

data/spec/standard_formatter_spec.rb

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'spec_helper'
+require 'date'
+
+describe StandardFormatter do
+  TIME_FORMAT = '%Y-%m-%d %H:%M:%S.%L'
+
+  let(:subject) { StandardFormatter.new }
+
+  describe 'when formatting a message' do
+    before do
+      @message = 'Hello, World'
+      @context = 'Custom::Context'
+      @level   = :info
+      @formatted_message = subject.format(@level, @context, @message)
+    end
+
+    it 'outputs the timestamp in %Y-%m-%d %H:%M:%S.%L format' do
+      # Dear god parsing times in Ruby is a pain so create a correctly formatted
+      # string then parse them both to compare them, otherwise timezones get
+      # crazy.
+      expected = to_time format_as_string(Time.now)
+      actual   = to_time @formatted_message
+      diff     = expected - actual
+
+      assert diff >= 0,  'must be no later expected'
+      assert diff <= 50, 'must be very recent'
+    end
+
+    it 'outputs the pid when run in the main thread' do
+      assert_equal Process.pid.to_s, thread_name
+    end
+
+    it 'converts the level to uppercase' do
+      assert_includes @formatted_message, @level.to_s.upcase
+    end
+
+    it 'formats the message after the time as expected' do
+      expected = "[#{Process.pid}] #{@level.to_s.upcase.ljust 5} #{@context} - #{@message}"
+      actual_without_time = @formatted_message[24..-1]
+
+      assert_equal expected, actual_without_time
+    end
+
+    describe 'when running in a thread' do
+      before do
+        @thread = Thread.new { subject.format(:info, @context, @message) }
+        @formatted_message = @thread.value
+      end
+
+      it 'outputs the pid and the thread object_id' do
+        assert_equal "#{Process.pid}##{@thread.object_id}", thread_name
+      end
+    end
+
+    def format_as_string(time)
+      time.strftime TIME_FORMAT
+    end
+
+    def to_time(string)
+      DateTime.strptime string[0..23], TIME_FORMAT
+    end
+
+    def thread_name
+      match = /\[([^\]]+)\]/.match(@formatted_message)
+      match[1]
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hatchet
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-07 00:00:00.000000000 Z
+date: 2012-07-08 00:00:00.000000000 Z
 dependencies: []
-description: Ruby logging library that provides the ability to add class/module specific
+description: Logging library that provides the ability to add class/module specific
   filters
 email:
 - garry@robustsoftware.co.uk
@@ -27,7 +27,16 @@ files:
 - lib/hatchet/standard_formatter.rb
 - lib/hatchet/version.rb
 - lib/hatchet.rb
-- test/experiment.rb
+- spec/configuration_spec.rb
+- spec/helpers/logger_double.rb
+- spec/helpers/simple_formatter.rb
+- spec/helpers/storing_appender.rb
+- spec/level_manager_spec.rb
+- spec/logger_appender_spec.rb
+- spec/logger_spec.rb
+- spec/message_spec.rb
+- spec/spec_helper.rb
+- spec/standard_formatter_spec.rb
 - LICENSE
 homepage: https://github.com/gshutler/hatchet
 licenses: []
@@ -41,24 +50,26 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2622354468754209643
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2622354468754209643
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
-summary: Ruby logging library that provides the ability to add class/module specific
-  filters
+summary: Logging library that provides the ability to add class/module specific filters
 test_files:
-- test/experiment.rb
+- spec/configuration_spec.rb
+- spec/helpers/logger_double.rb
+- spec/helpers/simple_formatter.rb
+- spec/helpers/storing_appender.rb
+- spec/level_manager_spec.rb
+- spec/logger_appender_spec.rb
+- spec/logger_spec.rb
+- spec/message_spec.rb
+- spec/spec_helper.rb
+- spec/standard_formatter_spec.rb

data/test/experiment.rb

@@ -1,47 +0,0 @@
-require_relative '../lib/hatchet'
-require 'logger'
-
-module Namespace
-  class Foo
-    include Hatchet
-
-    def work
-      log.fatal { "Fatal message will be shown" }
-    end
-  end
-
-  module Something
-    extend Hatchet
-
-    def self.work
-      log.info { "Info message will be shown" }
-      logger.debug { "Debug message won't be shown" }
-    end
-
-    class Nested
-      include Hatchet
-
-      def work
-        log.debug { "Debug message will be shown due to override" }
-      end
-    end
-  end
-end
-
-Hatchet.configure do |config|
-  config.level :info
-  config.level :debug, Namespace::Something::Nested
-
-  config.appenders << Hatchet::LoggerAppender.new do |appender|
-    appender.logger = Logger.new('log/test.log')
-  end
-end
-
-include Hatchet
-
-log.warn 'Warn message will be shown'
-thread = Thread.new { Namespace::Foo.new.work }
-Namespace::Something.work
-Namespace::Something::Nested.new.work
-
-thread.join