tagged_logger 0.2.1 → 0.2.5

data/.gitignore

@@ -2,4 +2,5 @@ pkg
 doc
 Manifest
 README.html
+CHANGES.html
 *.log

data/CHANGES.markdown

@@ -0,0 +1,13 @@
+# tagged_logger changelog
+
+## Version 0.2.5
+
+* If somebody is not ready to define any logging rules, but still want to use #logger everywhere, use new _init()_ method:
+
+    _TaggedLogger.init_
+
+* Runs about 3 times faster by executing code responsible for rule matching to the first _#logger()_ call and "precompiling" it.
+So rather than iterating over **all** rules on every _#logger_ call only subset of rules specific to _#logger()_ callee are executed.
+
+* Code simplified
+   

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.5

data/lib/tagged_logger.rb

@@ -2,30 +2,32 @@ require 'delegate'
 require 'facets/dictionary'
 
 class TaggedLogger
-  @logger_generator_exists = false
   @rename_rules = Dictionary.new
   @tag_blocks = Dictionary.new
-  
+
   class << self
     def reset
       @rename_rules = Dictionary.new
       @tag_blocks = Dictionary.new
+      ObjectSpace.each_object(ClassSpecificLogger) { |obj| obj.detach }
     end
     
     def rules(&block)
       instance_eval(&block)
     end
     
-    def log(level, tag, msg)
+    def blocks_for(tag)
+      blocks = []
       tag_aliases(tag) do |tag_alias|
         tag_blocks(tag_alias) do |tag_block|
-          tag_block.call(level, tag_alias, msg)
+          blocks << [tag_alias, tag_block]
         end
       end
+      blocks
     end
     
     def init
-      add_logger_generator_in_Object
+      add_logger_generator_in_Kernel
     end
     
     def output_everything_to(logger = nil, &block)
@@ -37,7 +39,7 @@ class TaggedLogger
     end
     
     def output(spec, &block)
-      add_logger_generator_in_Object
+      add_logger_generator_in_Kernel
       if spec.is_a? Hash
         spec.each do |what, where|
           @tag_blocks[tag_matcher(what)] = lambda { |level, tag, msg | where.send(level, "#{tag}: #{msg}\n") }
@@ -96,30 +98,43 @@ class TaggedLogger
       end
     end
     
-    def add_logger_generator_in_Object
-      return if @logger_generator_exists
-      @logger_generator_exists = true
-      Object.send(:define_method, "logger") do
-        self.class.class_eval do
-          attr_reader :class_logger
-          @class_logger = nil
-          def logger
-            return class_logger if class_logger
-            @class_logger = SimpleDelegator.new(TaggedLogger)
-            class_logging_tag = self.class == Class ?  self.to_s : self.class.to_s 
-            [:debug, :warn, :info, :error, :fatal].each do |method|
-              (class << @class_logger;self;end).instance_eval do
-                define_method method do |msg|
-                  __getobj__.log(method, class_logging_tag, msg)
-                end
-               end
-            end
+    def add_logger_generator_in_Kernel
+      return if Kernel.respond_to?(:logger, true) #no harm
+      Kernel.class_eval do
+        def logger
+          klass = self.class == Class ? self : self.class
+          result = klass.class_eval do
+            return @class_logger if @class_logger
+            @class_logger = ClassSpecificLogger.new(klass)
             @class_logger
           end
+          result
         end
-        logger
       end
     end
     
   end # class methods
+  
+  class ClassSpecificLogger
+    def eigenclass
+      class <<self; self; end
+    end
+
+    def initialize(klass)
+      @klass = klass
+      blocks = TaggedLogger.blocks_for(klass.to_s)
+      [:debug, :warn, :info, :error, :fatal].each do |method|
+        eigenclass.send(:define_method, method) do |msg|
+          blocks.each { |(tag_alias, block)| block.call(method, tag_alias, msg) }
+        end
+      end    
+    end
+    
+    def detach
+      @klass.class_eval do
+        @class_logger = nil
+      end
+    end
+  end
+  
 end

data/tagged_logger.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tagged_logger}
-  s.version = "0.2.1"
+  s.version = "0.2.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Fedor Kocherga"]
-  s.date = %q{2010-01-02}
+  s.date = %q{2010-01-13}
   s.email = %q{fkocherga@gmail.com}
   s.extra_rdoc_files = [
     "README.html",
@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     "CHANGES.markdown",
      "MIT-LICENSE",
      "README.markdown",
      "Rakefile",

data/test/test.rb

@@ -18,7 +18,8 @@ end
 class TaggedLoggerTest < Test::Unit::TestCase
   include RR::Adapters::TestUnit
 
-  context "@standard_logger writing to device @out1" do
+  
+  context "@standard_logger with stub output @out1;" do
     setup do
       @out1 = TestLogDevice.new
       @standard_logger = Logger.new(@out1)
@@ -26,6 +27,12 @@ class TaggedLoggerTest < Test::Unit::TestCase
       @standard_logger.formatter = @formatter
     end
     
+    teardown do
+      Kernel.class_eval do
+        remove_method :logger
+      end
+    end
+    
     should "be able to intialize with minimal effort" do
       TaggedLogger.init
       dont_allow(@out1).write
@@ -33,7 +40,7 @@ class TaggedLoggerTest < Test::Unit::TestCase
       assert_nothing_raised { Class.new.logger }
     end
     
-    context "any attempt to log something goes to @standard_logger" do
+    context "everything gets logged to @out1;" do
       setup do 
         logger = @standard_logger
         TaggedLogger.rules do
@@ -42,7 +49,7 @@ class TaggedLoggerTest < Test::Unit::TestCase
         end
       end
       
-      should "do logging with different levels" do
+      should " be possible to log by .logger.debug/info/warn/error/fatal()" do
         NewClass = Class.new
         obj = NewClass.new
         %w[debug info warn error fatal].each do |method|
@@ -78,14 +85,14 @@ class TaggedLoggerTest < Test::Unit::TestCase
           assert_equal "TEST: foo\n", @out1.to_s
         end
 
-        context "specialized logging" do
+        context "@logger2 with stub output @out2;" do
           setup do 
             @out2 = TestLogDevice.new
             @logger2 = Logger.new(@out2)
             @logger2.formatter = @formatter
           end
           
-          should "be possible to speialize logging for tag A by specifying different logger" do
+          should "be possible to speialize logging for tag A by specifying another @logger2" do
             logger2 = @logger2
             TaggedLogger.rules do
               output A => logger2

data/todo.txt

@@ -1 +1,21 @@
-1. Simplest configuration with warning
+- It is slow: logger on first call has to select only applicable rules and 
+  run only them afterwards rather than going via all rules each time. It will
+  gain almost 300% in parsing speed on my app.
+
+- Replace output ... => ... with
+  format ...
+  output ... => do
+     format ....
+  end
+
+- output ... => ... - may be:
+     debug ... => ...
+     info ... => ...
+
+- Simplest configuration with warning
+
+- Switch tests on rr expectations
+
+- logger called within Base does not log when Derived is instantiated
+
+- writing messages in any encoding

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tagged_logger
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.2.5
 platform: ruby
 authors: 
 - Fedor Kocherga
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-02 00:00:00 -06:00
+date: 2010-01-13 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,7 @@ extra_rdoc_files:
 - README.markdown
 files: 
 - .gitignore
+- CHANGES.markdown
 - MIT-LICENSE
 - README.markdown
 - Rakefile