lumber 0.0.2 → 0.9.0

data/CHANGELOG

@@ -1,3 +1,10 @@
+0.9.0
+-----
+
+get working with nested classes, prevent rails from overriding logger <b9fecdd> [Matt Conway]
+some doc changes <334f2de> [Matt Conway]
+add dependency to ActiveSupport, Refactor to remove dependency on load order, Add tests <beb8769> [Matt Conway]
+
 0.0.2
 -----
 

data/README.rdoc

@@ -13,19 +13,17 @@ to config/environment.rb:
   require 'lumber'
   Lumber.init()
 
-  # If you really want all classes to have a logger
-  # Lumber.setup_logger_hierarchy(Object, "root::object")
+  # Setup parent loggers for some known rails Base classes.  Classes that inherit
+  # from these will have their logger as a parent so you can configure logging for
+  # subtrees of classes in log4r.yml
+  Lumber.setup_logger_hierarchy("ActiveRecord::Base", "rails::models")
+  Lumber.setup_logger_hierarchy("ActionController::Base", "rails::controllers")
+  Lumber.setup_logger_hierarchy("ActionMailer::Base", "rails::mailers")
 
-  # Inside the block for Rails::Initializer.run
-  #
-  config.after_initialize do
-    # setup log4r hierarchy - these need to happen after frameworks
-    # are loaded, but before subclasses get defined
-    Lumber.setup_logger_hierarchy(ActiveRecord::Base, "rails::models")
-    Lumber.setup_logger_hierarchy(ActionController::Base, "rails::controllers")
-    Lumber.setup_logger_hierarchy(ActionMailer::Base, "rails::mailers")
-  end
+  # If you really want, you can make all classes have a logger
+  # Lumber.setup_logger_hierarchy("Object", "root::object")
 
+    
 If you want to change the log level for a different environment, add a line like below to the config/environments/<env>.rb
 
   # Set info as the default log level for production

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.9.0

data/lib/lumber/lumber.rb

@@ -1,4 +1,7 @@
 require "socket"
+require "active_support/core_ext/duplicable"
+require "active_support/core_ext/class"
+require "active_support/core_ext/module"
 
 module Lumber
 
@@ -36,16 +39,18 @@ module Lumber
     end
     Object.const_set('RAILS_DEFAULT_LOGGER', Log4r::Logger['rails'])
 
+    @@registered_loggers = {}
+    self.register_inheritance_handler()
   end
 
   # Makes :logger exist independently for subclasses and sets that logger
-  # to one that inherits from base_class for each subclass as its created.
+  # to one that inherits from base_class for each subclass as it is created.
   # This allows you to have a finer level of control over logging, for example,
   # put just a single class, or hierarchy of classes, into debug log level
   #
   # for example:
   #
-  #   Lumber.setup_logger_hierarchy(ActiveRecord::Base, "rails::models")
+  #   Lumber.setup_logger_hierarchy("ActiveRecord::Base", "rails::models")
   #
   # causes all models that get created to have a log4r logger named
   # "rails::models::<class_name>".  This class can individually be
@@ -53,36 +58,96 @@ module Lumber
   # output will include "<class_name>" on every log from this class
   # so that you can tell where a log statement came from
   #
-  def self.setup_logger_hierarchy(base_class, parent_fullname)
-    base_class.class_eval do
-      class_inheritable_accessor :logger
-      self.logger = Log4r::Logger.new(parent_fullname)
+  def self.setup_logger_hierarchy(class_name, class_logger_fullname)
+    @@registered_loggers[class_name] = class_logger_fullname
+
+    obj = nil
+    names = class_name.split '::'
+    names.each do |name|
+      root ||= Object
+      if root.const_defined?(name)
+        obj = root.const_get(name)
+        root = obj
+      else
+        obj = nil
+      end
+    end
+
+    if obj
+      obj.class_eval do
+        class_inheritable_accessor :logger
+        self.logger = Log4r::Logger.new(class_logger_fullname)
+      end
+    end
+  end
 
+  private
+
+  # Adds a inheritance handler to Object so we can know to add loggers
+  # for classes as they get defined.
+  def self.register_inheritance_handler()
+    return if defined?(Object.inherited_with_lumber_log4r)
+    
+    Object.class_eval do
+      
       class << self
+
         def inherited_with_lumber_log4r(subclass)
           inherited_without_lumber_log4r(subclass)
-          # p "#{self} -> #{subclass} -> #{self.logger}"
-
-          # Look up the class hierarchy for a useable logger
-          # A class may have a nil logger if it was created
-          # before we add logger/inheritance to its superclas,
-          # e.g. Object/Exception - something tries to subclass
-          # Exception after we added lumber_inherited to Object,
-          # but Exception was defined before we added lumber_inherited 
-          while self.logger.nil?
-            next_class = (next_class ||self).superclass
-            if next_class.nil?
-              self.logger = Log4r::Logger.root
-            else
-              self.logger = next_class.logger
-            end
+
+          # if the new class is in the list that were registered directly,
+          # then create their logger attribute directly, otherwise derive it
+          logger_name = @@registered_loggers[subclass.name]
+          if logger_name
+            Lumber.add_lumber_logger(subclass, logger_name)
+          else
+            Lumber.derive_lumber_logger(subclass)
           end
-          subclass.logger = Log4r::Logger.new("#{logger.fullname}::#{subclass.name}")
         end
+        
         alias_method_chain :inherited, :lumber_log4r
+
+      end
+
+    end
+
+  end
+
+  def self.add_lumber_logger(clazz, logger_name)
+    clazz.class_eval do
+
+      class_inheritable_accessor :logger
+      self.logger = Log4r::Logger.new(logger_name)
+
+      class << self
+
+        # Prevent rails from overwriting our logger
+        def cattr_accessor_with_lumber_log4r(*syms)
+          without_logger = syms.reject {|s| s == :logger}
+          cattr_accessor_without_lumber_log4r(*without_logger)
+        end
+        alias_method_chain :cattr_accessor, :lumber_log4r
+
       end
 
     end
   end
 
+  def self.derive_lumber_logger(clazz)
+    # otherwise, walk up the classes hierarchy till you find a logger
+    # that was registered, and use that logger as the parent for the
+    # logger of the new class
+    parent = clazz.superclass
+    while ! parent.nil?
+      if defined?(parent.logger) && parent.logger
+        parent_is_registered = @@registered_loggers.values.find {|v| parent.logger.fullname.index(v) == 0}
+        if parent_is_registered
+          clazz.logger = Log4r::Logger.new("#{parent.logger.fullname}::#{clazz.name}")
+          break
+        end
+      end
+      parent = parent.superclass
+    end
+  end
+
 end

data/test/lumber_test.rb

@@ -1,7 +1,117 @@
 require 'test_helper'
 
+
+def new_class(class_name, super_class=nil, super_module=nil)
+  s = "class #{class_name}"
+  s << " < #{super_class}" if super_class
+  s << "; end"
+
+  s = "module #{super_module}; #{s}; end" if super_module
+  
+  eval s
+end
+
 class LumberTest < 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"
+
+  def setup
+    root = "#{File.dirname(__FILE__)}/.."
+    Lumber.init(:root => root,
+                :env => 'test',
+                :config_file => "#{root}/generators/lumber/templates/log4r.yml",
+                :log_file => "/tmp/lumber-test.log")
+  end
+
+  def teardown
+    Object.constants.grep(/^Foo/).each do |c|
+      Object.send(:remove_const, c)
+    end
+  end
+
+  def assert_valid_logger(class_name, logger_name)
+    clazz = eval class_name
+    assert clazz
+    assert clazz.respond_to?(:logger)
+    lgr = clazz.logger
+    assert lgr.instance_of?(Log4r::Logger)
+    assert_equal logger_name, lgr.fullname
+  end
+
+  should "not do anything if no loggers registered" do
+    assert defined?(Object.inherited_with_lumber_log4r)
+    assert ! defined?(Object.logger)
+  end
+
+  should "allow registering logger for a class before the class is defined" do
+    assert !defined?(Foo1)
+    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+    new_class('Foo1')
+    assert_valid_logger('Foo1', "root::foo1")
+  end
+
+  should "prevent cattr_accessor for a class registered before the class is defined" do
+    assert !defined?(Foo1)
+    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+    new_class('Foo1')
+    Foo1.class_eval do
+      cattr_accessor :logger, :foo
+    end
+    assert defined?(Foo1.foo)
+    assert_valid_logger('Foo1', "root::foo1")
+  end
+
+  should "allow registering logger for a nested class before the class is defined" do
+    assert !defined?(Bar1::Foo1)
+    Lumber.setup_logger_hierarchy("Bar1::Foo1", "root::foo1")
+    new_class('Foo1', nil, 'Bar1')
+    assert_valid_logger('Bar1::Foo1', "root::foo1")
+  end
+
+  should "allow registering logger for a class after the class is defined" do
+    assert !defined?(Foo1)
+    new_class('Foo1')
+    assert defined?(Foo1)
+
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    assert_valid_logger('Foo1', "root::Foo1")
+  end
+
+  should "register loggers for subclasses of registered classes" do
+    assert !defined?(Foo1)
+    assert !defined?(Foo2)
+    assert !defined?(Foo3)
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    new_class('Foo1')
+    new_class('Foo2', 'Foo1')
+    new_class('Foo3')
+    assert_valid_logger('Foo1', "root::Foo1")
+    assert_valid_logger('Foo2', "root::Foo1::Foo2")
+    assert ! defined?(Foo3.logger)
+  end
+
+  should "register loggers for sub-subclasses of registered classes" do
+    assert !defined?(Foo1)
+    assert !defined?(Foo2)
+    assert !defined?(Foo3)
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    new_class('Foo1')
+    new_class('Foo2', 'Foo1')
+    new_class('Foo3', 'Foo2')
+    assert_valid_logger('Foo1', "root::Foo1")
+    assert_valid_logger('Foo2', "root::Foo1::Foo2")
+    assert_valid_logger('Foo3', "root::Foo1::Foo2::Foo3")
+  end
+
+  should "register loggers for sub-subclasses of registered classes even when middle class not a logger" do
+    assert !defined?(Foo1)
+    assert !defined?(Foo2)
+    assert !defined?(Foo3)
+    new_class('Foo1')
+    new_class('Foo2', 'Foo1')
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    new_class('Foo3', 'Foo2')
+    assert_valid_logger('Foo1', "root::Foo1")
+    assert !defined?(Foo2.logger) || Foo2.logger.nil?
+    assert_valid_logger('Foo3', "root::Foo1::Foo3")
   end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lumber
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.9.0
 platform: ruby
 authors: 
 - Matt Conway
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-15 00:00:00 -04:00
+date: 2009-10-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: active_support
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: Lumber tries to make it easy to use the more robust log4r logging system within your rails application.  To do this it sets up log4r configuration from a yml file, and provides utility methods for adding a :logger accessor to classes dynamicaly as they get created.
 email: matt@conwaysplace.com
 executables: []
@@ -77,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.4
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Lumber integrates the log4r logging system within your application.