RubyGems - tagged_logger - Versions diffs - 0.2.0 → 0.2.1 - Mend

tagged_logger 0.2.0 → 0.2.1

Files changed (20) hide show

data/.gitignore +2 -1
data/README.html +91 -0
data/README.markdown +90 -0
data/Rakefile +0 -64
data/VERSION +1 -1
data/examples/one_log_per_classes.rb +1 -3
data/examples/one_tag_per_classes.rb +1 -1
data/examples/per_class_customization.rb +2 -5
data/examples/rule_with_regex.rb +1 -3
data/examples/simplest_customization.rb +1 -1
data/examples/simplest_usage.rb +1 -1
data/lib/tagged_logger.rb +11 -7
data/tagged_logger.gemspec +7 -71
data/test/test.rb +99 -88
data/todo.txt +1 -0
metadata +8 -70
data/README.rdoc +0 -63
data/active.log +0 -2
data/database.log +0 -2
data/network.log +0 -2

data/.gitignore CHANGED Viewed

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

data/README.html ADDED Viewed

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC
+    "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN"
+    "http://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd">
+<html xmlns:svg='http://www.w3.org/2000/svg' xml:lang='en' xmlns='http://www.w3.org/1999/xhtml'>
+<head><meta content='application/xhtml+xml;charset=utf-8' http-equiv='Content-type' /><title>TaggedLogger</title></head>
+<body>
+<h1 id='taggedlogger'>TaggedLogger</h1>
+<p>Detaches <strong>what</strong> is logged from <strong>how</strong> it is logged.</p>
+<h2 id='what_is_it_for'>What is it for?</h2>
+<p>Everytime you want to log something, simply write:</p>
+<pre><code>logger.debug(&quot;verbose debug information&quot;) #warn, #info, #error, #fatal also work</code></pre>
+<p>and do not worry about what kind of logger you use and how your code accesses it. You may confugure these things later, one day writing to STDOUT works for you, another day you&#8217;ll need something more sofisticated - like several log files each serving different components, and for different audience.</p>
+<h2 id='installation'>Installation</h2>
+<pre><code>$ sudo gem install tagged_logger --source=http://gemcutter.org</code></pre>
+<h2 id='usage'>Usage</h2>
+<p>The simplest way to turn logging on for every class whose methods calls <em>#logger</em></p>
+<pre><code>TaggedLogger.rules do
+  out_everything_to Logger.new(STDOUT)
+end</code></pre>
+<p>From now on you may call <em>#logger</em> from anywhere, for example:</p>
+<pre><code>class IWantToLogThis
+  def foo
+    logger.warn &quot;foo&quot;
+  end
+end</code></pre>
+<p>and after execution of:</p>
+<pre><code>IWantToLogThis.new.foo</code></pre>
+<p>you will see somewhat like:</p>
+<pre><code>W, [2009-12-20T21:45:02.443524 #37166]  WARN -- : IWantToLogThis: foo</code></pre>
+<p>You may define your own formatting:</p>
+<pre><code>TaggedLogger.rules do
+  out /.*/ do |level, tag, msg|
+    puts &quot;#{level}-#{tag}: #{msg}&quot;
+  end
+end</code></pre>
+<p>The &#8216;/.*/&#8217; says that rule is applied for every class (i.e. class name matches /.*/). The <em>level</em> and <em>msg</em> semantics should be obvious, they are severity threshold and being logged message, but <em>tag</em> is something not so obvious - it is class name whose method calls <em>#logger</em>. In example above tag is &#8220;IWantToLogThis&#8221; since <em>IWantToLogThis#foo</em> calls <em>#logger</em>. Note the <em>#logger</em> does not have <em>tag</em> parameter - tags defined automatically and they are always class names.</p>
+<p>If you decided to have separate log files for classes <em>Network</em> and <em>Database</em>:</p>
+<pre><code>TaggedLogger.rules do
+  out Network =&gt; Logger.new(&quot;network.log&quot;)
+  out Database =&gt; Logger.new(&quot;database.log&quot;)
+end</code></pre>
+<p>In case you want to define common log for several classes:</p>
+<pre><code>TaggedLogger.rules do
+  out [Ftp, Http, Sockets] =&gt; Logger.new(&quot;network.log&quot;)
+end </code></pre>
+<p>Or if you want to have all these classes showing up under common tag <em>Network</em> in standard output:</p>
+<pre><code>TaggedLogger.rules do
+  out_everything_to Logger.new(STDOUT)
+  rename [Ftp, Http, Sockets] =&gt; :Network
+end</code></pre>
+<p>You may also use regular expressions in your rules:</p>
+<pre><code>TaggedLogger.rules do
+  out /Active::/ =&gt; Logger.new(&quot;active.log&quot;)
+end</code></pre>
+<h2 id='license'>License</h2>
+<p>TaggedLogger is released under the MIT license.</p>
+<h2 id='shortcumings'>Shortcumings</h2>
+<p>Was not tested with <em>log4r</em></p>
+</body></html>

data/README.markdown ADDED Viewed

@@ -0,0 +1,90 @@
+# TaggedLogger
+Detaches **what** is logged from **how** it is logged.
+## What is it for?
+Every time you want to log something, simply write:
+    logger.debug("verbose debug information") #warn, #info, #error, #fatal also work
+and do not worry about what kind of logger you use and how your code accesses it.
+You may configure these things later, one day writing to STDOUT works for you, another
+day you'll need something more sophisticated, like several log files each serving
+different components and for different audience.
+## Installation
+    $ sudo gem install tagged_logger --source=http://gemcutter.org
+## Usage
+The simplest way to turn logging on for every class whose methods calls *#logger*
+    TaggedLogger.rules do
+      output_everything_to Logger.new(STDOUT)
+    end
+From now on you may call *#logger* from anywhere, for example:
+    class IWantToLogThis
+      def foo
+        logger.warn "foo"
+      end
+    end
+and after execution of:
+    IWantToLogThis.new.foo
+you will see somewhat like:
+    W, [2009-12-20T21:45:02.443524 #37166]  WARN -- : IWantToLogThis: foo
+You may define your own formatting:
+    TaggedLogger.rules do
+      output /.*/ do |level, tag, msg|
+        puts "#{level}-#{tag}: #{msg}"
+      end
+    end
+The '/.\*/' says that rule is applied for every class (i.e. class name matches /.\*/).
+The *level* and *msg* semantics should be obvious, they are severity threshold
+and being logged message, but *tag* is something not so obvious - it is class name whose
+method calls *#logger*. In example above tag is "IWantToLogThis" since *IWantToLogThis#foo*
+calls *#logger*. Note the *#logger* does not have *tag* parameter - tags defined automatically
+and they are always class names.
+  If you decided to have separate log files for classes *Network* and *Database*:
+    TaggedLogger.rules do
+      output Network => Logger.new("network.log")
+      output Database => Logger.new("database.log")
+    end
+In case you want to define common log for several classes:
+    TaggedLogger.rules do
+      output [Ftp, Http, Sockets] => Logger.new("network.log")
+    end
+Or if you want to have all these classes showing up under common
+tag *Network* in standard output:
+    TaggedLogger.rules do
+      output_everything_to Logger.new(STDOUT)
+      rename [Ftp, Http, Sockets] => :Network
+    end
+You may also use regular expressions in your rules:
+    TaggedLogger.rules do
+      output /Active::/ => Logger.new("active.log")
+    end
+## License
+TaggedLogger is released under the MIT license.
+## Shortcomings
+Was not tested with *log4r*

data/Rakefile CHANGED Viewed

@@ -15,70 +15,6 @@ begin
     s.summary = "Detaches _what_ is logged from _how_ it is logged."
     s.email = "fkocherga@gmail.com"
     s.homepage = "http://github.com/fkocherga/tagged_logger"
-    s.description = <<'END'
-This gem supposed to help you to forget about how to expose logging
-facitilities to the code you write. Any time you want to log something,
-simply do one of:
-   logger.debug("verbose debug information") #or
-   logger.warn("warning")  #or
-   logger.info("information you frequently want to see") #or
-   logger.error("errors") #or
-   logger.fatal("fatal errors")
-and do not worry about where the '#logger' is and what it does at the moment,
-you will have a chance to configure it in place where you confugure other things.
-So you may focus on _what_ to put in the logging rather on how to set it up.
-Later you may turn logging on for specific class or bunch of classes or in case
-you have special logging demands for specific classes you also may specify it
-in very simple way.
-The simplest way to turn logging on for every class whose methods calls '#logger':
-    TaggedLogger.rules do
-      out_everything_to Logger.new(STDOUT)
-    end
-or you may cook it in your special way:
-    TaggedLogger.rules do
-      out /.*/ do |level, tag, msg|
-        puts "#{level}-#{tag}: #{msg}"
-      end
-    end
-Where 'tag' is the simple class name whose method calls '#logger'. Note,
-you do not have to implement '#logger' method anywhere. It gets
-automatically generated by specifying any of 'out' rules.
-  You may be even more picky about what and where to log. Imagine
-you have 'Network' and 'Database' classes and you want to have
-separate log files for them, it is easy:
-    TaggedLogger.rules do
-      out Network => Logger.new("network.log")
-      out Database => Logger.new("database.log")
-    end
-In case you want to define common log for several classes:
-  TaggedLogger.rules do
-    out [Ftp, Http, Sockets] => Logger.new("network.log")
-  end
-Or if you want to have all these classes showing up under common
-tag 'Network' in standard output:
-    TaggedLogger.rules do
-      out_everything_to Logger.new(STDOUT)
-      rename [Ftp, Http, Sockets] => :Network
-    end
-You may also use regular expressions in your rules:
-  TaggedLogger.rules do
-    out /Active::/ => Logger.new("active.log")
-  end
-END
     s.authors = ["Fedor Kocherga"]
     s.test_files = ['test/test.rb']
   end

data/VERSION CHANGED Viewed

	@@ -1 +1 @@
1	- 0.2.0
1	+ 0.2.1

data/examples/one_log_per_classes.rb CHANGED Viewed

@@ -12,10 +12,8 @@ Ftp = Class.new LogFoo
 Http = Class.new LogFoo
 Sockets = Class.new LogFoo
-`rm -f network.log`
 TaggedLogger.rules do
-  out [Ftp, Http, Sockets] => Logger.new("network.log")
+  output [Ftp, Http, Sockets] => Logger.new(open("network.log", "w"))
 end
 [Ftp, Http, Sockets].each { |c| c.new.foo }
-IO.foreach('network.log') { |line| puts line }

data/examples/one_tag_per_classes.rb CHANGED Viewed

@@ -13,8 +13,8 @@ Http = Class.new { include LogFoo }
 Sockets = Class.new { include LogFoo }
 TaggedLogger.rules do
-  out_everything_to Logger.new(STDOUT)
   rename [Ftp, Http, Sockets] => :Network
+  output :Network => Logger.new(STDOUT)
 end
 [Ftp, Http, Sockets].each { |c| c.new.foo }

data/examples/per_class_customization.rb CHANGED Viewed

@@ -11,12 +11,9 @@ end
 Database = Class.new LogFoo
 Network = Class.new LogFoo
-`rm -f network.log`
-`rm -f database.log`
 TaggedLogger.rules do
-  out Network => Logger.new("network.log")
-  out Database => Logger.new("database.log")
+  output Network => Logger.new(open("network.log", "w"))
+  output Database => Logger.new(open("database.log", "w"))
 end
 Database.new.foo

data/examples/rule_with_regex.rb CHANGED Viewed

@@ -10,10 +10,8 @@ module Active
   end
 end
-`rm -f active.log`
 TaggedLogger.rules do
-  out /Active::/ => Logger.new("active.log")
+  output /Active::/ => Logger.new(open("active.log", "w"))
 end
 Active::Base.new.foo

data/examples/simplest_customization.rb CHANGED Viewed

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'tagged_logger'
 TaggedLogger.rules do
-  out /.*/ do |level, tag, msg|
+  output /.*/ do |level, tag, msg|
     puts "#{level}-#{tag}: #{msg}"
   end
 end

data/examples/simplest_usage.rb CHANGED Viewed

@@ -3,7 +3,7 @@ require 'tagged_logger'
 require 'logger'
 TaggedLogger.rules do
-  out_everything_to Logger.new(STDOUT)
+  output_everything_to Logger.new(STDOUT)
 end
 class A

data/lib/tagged_logger.rb CHANGED Viewed

@@ -24,23 +24,27 @@ class TaggedLogger
       end
     end
-    def out_everything_to(logger = nil, &block)
+    def init
+      add_logger_generator_in_Object
+    end
+    def output_everything_to(logger = nil, &block)
       if logger && block
         raise ArgumentError, "Either block or logger has to be specified, but not both."
       end
-      out /.*/ => logger if logger
-      oout &block if block
+      output /.*/ => logger if logger
+      output &block if block
     end
-    def out(spec, &block)
+    def output(spec, &block)
       add_logger_generator_in_Object
       if spec.is_a? Hash
         spec.each do |what, where|
-          @tag_blocks[tag_matcher(what)] = lambda { |level, tag, msg | where.send(level, "#{tag}: #{msg}") }
+          @tag_blocks[tag_matcher(what)] = lambda { |level, tag, msg | where.send(level, "#{tag}: #{msg}\n") }
         end
-        raise ArgumentError "No block should be specified in this 'out' rule" if block
+        raise ArgumentError "No block should be specified in this 'output' rule" if block
       else
-        raise ArgumentError "Block has to be specified in this 'out' rule" unless block
+        raise ArgumentError "Block has to be specified in this 'output' rule" unless block
         @tag_blocks[tag_matcher(spec)] = block
       end
     end

data/tagged_logger.gemspec CHANGED Viewed

@@ -5,86 +5,22 @@
 Gem::Specification.new do |s|
   s.name = %q{tagged_logger}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Fedor Kocherga"]
-  s.date = %q{2009-12-20}
-  s.description = %q{This gem supposed to help you to forget about how to expose logging
-facitilities to the code you write. Any time you want to log something,
-simply do one of:
-   logger.debug("verbose debug information") #or
-   logger.warn("warning")  #or
-   logger.info("information you frequently want to see") #or
-   logger.error("errors") #or
-   logger.fatal("fatal errors")
-and do not worry about where the '#logger' is and what it does at the moment,
-you will have a chance to configure it in place where you confugure other things.
-So you may focus on _what_ to put in the logging rather on how to set it up.
-Later you may turn logging on for specific class or bunch of classes or in case
-you have special logging demands for specific classes you also may specify it
-in very simple way.
-The simplest way to turn logging on for every class whose methods calls '#logger':
-    TaggedLogger.rules do
-      out_everything_to Logger.new(STDOUT)
-    end
-or you may cook it in your special way:
-    TaggedLogger.rules do
-      out /.*/ do |level, tag, msg|
-        puts "#{level}-#{tag}: #{msg}"
-      end
-    end
-Where 'tag' is the simple class name whose method calls '#logger'. Note,
-you do not have to implement '#logger' method anywhere. It gets
-automatically generated by specifying any of 'out' rules.
-  You may be even more picky about what and where to log. Imagine
-you have 'Network' and 'Database' classes and you want to have
-separate log files for them, it is easy:
-    TaggedLogger.rules do
-      out Network => Logger.new("network.log")
-      out Database => Logger.new("database.log")
-    end
-In case you want to define common log for several classes:
-  TaggedLogger.rules do
-    out [Ftp, Http, Sockets] => Logger.new("network.log")
-  end
-Or if you want to have all these classes showing up under common
-tag 'Network' in standard output:
-    TaggedLogger.rules do
-      out_everything_to Logger.new(STDOUT)
-      rename [Ftp, Http, Sockets] => :Network
-    end
-You may also use regular expressions in your rules:
-  TaggedLogger.rules do
-    out /Active::/ => Logger.new("active.log")
-  end
-}
+  s.date = %q{2010-01-02}
   s.email = %q{fkocherga@gmail.com}
   s.extra_rdoc_files = [
-    "README.rdoc"
+    "README.html",
+     "README.markdown"
   ]
   s.files = [
     ".gitignore",
      "MIT-LICENSE",
-     "README.rdoc",
+     "README.markdown",
      "Rakefile",
      "VERSION",
-     "active.log",
-     "database.log",
      "examples/one_log_per_classes.rb",
      "examples/one_tag_per_classes.rb",
      "examples/per_class_customization.rb",
@@ -92,10 +28,10 @@ You may also use regular expressions in your rules:
      "examples/simplest_customization.rb",
      "examples/simplest_usage.rb",
      "lib/tagged_logger.rb",
-     "network.log",
      "tagged_logger.gemspec",
      "tagged_logger.rb",
-     "test/test.rb"
+     "test/test.rb",
+     "todo.txt"
   ]
   s.homepage = %q{http://github.com/fkocherga/tagged_logger}
   s.rdoc_options = ["--charset=UTF-8"]

data/test/test.rb CHANGED Viewed

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'test/unit'
 require 'shoulda'
 require 'logger'
+require 'rr'
 require File.dirname(__FILE__) + '/../tagged_logger'
@@ -15,121 +16,131 @@ class TestLogDevice
 end
 class TaggedLoggerTest < Test::Unit::TestCase
-  context "#logger() generated for every class, logging goes to String @out1;" do
-    setup do
+  include RR::Adapters::TestUnit
+  context "@standard_logger writing to device @out1" do
+    setup do
       @out1 = TestLogDevice.new
-      standard_logger = Logger.new(@out1)
+      @standard_logger = Logger.new(@out1)
       @formatter = lambda {|severity, datetime, progname, msg| "#{msg}"}
-      standard_logger.formatter = @formatter
-      TaggedLogger.rules do
-        reset
-        out_everything_to standard_logger
-      end
+      @standard_logger.formatter = @formatter
     end
-    should "include #logger in every class" do
+    should "be able to intialize with minimal effort" do
+      TaggedLogger.init
+      dont_allow(@out1).write
       assert Class.new.methods.include? "logger"
+      assert_nothing_raised { Class.new.logger }
     end
-    should "do logging with different levels" do
-      NewClass = Class.new
-      obj = NewClass.new
-      %w[debug info warn error fatal].each do |method|
-        assert obj.logger.methods.include? method
-        obj.logger.send(method.intern, method)
-        assert_equal "#{obj.class}: #{method}", @out1.to_s
-      end
-    end
-    context "class A and class B with logging;" do
-      setup do
-        module Foo
-          def foo
-            logger.info("foo")
-          end
+    context "any attempt to log something goes to @standard_logger" do
+      setup do
+        logger = @standard_logger
+        TaggedLogger.rules do
+          reset
+          output_everything_to logger
         end
-        class A;include Foo; end
-        class B;include Foo; end
-        @a = A.new
-        @b = B.new
       end
-      should "be possible to replace tags for A, B classes with single tag TEST making rules for A and B obsolete" do
-        TaggedLogger.rules do
-          rename [A,B] => :TEST
+      should "do logging with different levels" do
+        NewClass = Class.new
+        obj = NewClass.new
+        %w[debug info warn error fatal].each do |method|
+          assert obj.logger.methods.include? method
+          obj.logger.send(method.intern, method)
+          assert_equal "#{obj.class}: #{method}\n", @out1.to_s
         end
-        @a.foo
-        assert_equal "TEST: foo", @out1.to_s
-        @out1.clear
-        @b.foo
-        assert_equal "TEST: foo", @out1.to_s
       end
-      context "specialized logging" do
-        setup do
-          @out2 = TestLogDevice.new
-          @logger2 = Logger.new(@out2)
-          @logger2.formatter = @formatter
+      context "class A and class B with logging;" do
+        setup do
+          module Foo
+            def foo
+              logger.info("foo")
+            end
+          end
+          class A;include Foo; end
+          class B;include Foo; end
+          @a = A.new
+          @b = B.new
         end
-        should "be possible to speialize logging for tag A by specifying different logger" do
-          logger2 = @logger2
+        should "be possible to replace tags for A, B classes with single tag TEST making rules for A and B obsolete" do
           TaggedLogger.rules do
-            out A => logger2
+            rename [A,B] => :TEST
           end
           @a.foo
-          assert_equal "#{self.class}::A: foo", @out1.to_s
-          assert_equal "#{self.class}::A: foo", @out2.to_s
-          @out2.clear
+          assert_equal "TEST: foo\n", @out1.to_s
+          @out1.clear
           @b.foo
-          assert_equal "#{self.class}::B: foo", @out1.to_s
-          assert_equal "", @out2.to_s
+          assert_equal "TEST: foo\n", @out1.to_s
         end
-        should "be possible to speialize logging for tag A by providing block" do
-          logger2 = @logger2
-          TaggedLogger.rules do
-            out A do |level, tag, msg|
-              logger2.send(level, msg)
+        context "specialized logging" 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
+            logger2 = @logger2
+            TaggedLogger.rules do
+              output A => logger2
             end
+            @a.foo
+            assert_equal "#{self.class}::A: foo\n", @out1.to_s
+            assert_equal "#{self.class}::A: foo\n", @out2.to_s
+            @out2.clear
+            @b.foo
+            assert_equal "#{self.class}::B: foo\n", @out1.to_s
+            assert_equal "", @out2.to_s
           end
-          @a.foo
-          assert_equal "#{self.class}::A: foo", @out1.to_s
-          assert_equal "foo", @out2.to_s
-          @out2.clear
-          @b.foo
-          assert_equal "#{self.class}::B: foo", @out1.to_s
-          assert_equal "", @out2.to_s
-        end
-        should "be possible to replace tags for A, B classes with single tag TEST and specialize logging for it" do
-          logger2 = @logger2
-          TaggedLogger.rules do
-            rename [A, B] => :TEST
-            out :TEST => logger2
+          should "be possible to speialize logging for tag A by providing block" do
+            logger2 = @logger2
+            TaggedLogger.rules do
+              output A do |level, tag, msg|
+                logger2.send(level, msg)
+              end
+            end
+            @a.foo
+            assert_equal "#{self.class}::A: foo\n", @out1.to_s
+            assert_equal "foo", @out2.to_s
+            @out2.clear
+            @b.foo
+            assert_equal "#{self.class}::B: foo\n", @out1.to_s
+            assert_equal "", @out2.to_s
           end
-          @a.foo
-          assert_equal "TEST: foo", @out1.to_s
-          assert_equal "TEST: foo", @out2.to_s
-          @out1.clear
-          @out2.clear
-          @b.foo
-          assert_equal "TEST: foo", @out1.to_s
-          assert_equal "TEST: foo", @out2.to_s
-        end
-        should "use default tag equal to class name for class methods" do
-          def A.bar
-            logger.info "bar"
+          should "be possible to replace tags for A, B classes with single tag TEST and specialize logging for it" do
+            logger2 = @logger2
+            TaggedLogger.rules do
+              rename [A, B] => :TEST
+              output :TEST => logger2
+            end
+            @a.foo
+            assert_equal "TEST: foo\n", @out1.to_s
+            assert_equal "TEST: foo\n", @out2.to_s
+            @out1.clear
+            @out2.clear
+            @b.foo
+            assert_equal "TEST: foo\n", @out1.to_s
+            assert_equal "TEST: foo\n", @out2.to_s
+          end
+          should "use default tag equal to class name for class methods" do
+            def A.bar
+              logger.info "bar"
+            end
+            A.bar
+            assert_equal "#{self.class}::A: bar\n", @out1.to_s
           end
-          A.bar
-          assert_equal "#{self.class}::A: bar", @out1.to_s
         end
       end
     end
   end

data/todo.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ 1. Simplest configuration with warning

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tagged_logger
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Fedor Kocherga
@@ -9,88 +9,25 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-12-20 00:00:00 -06:00
+date: 2010-01-02 00:00:00 -06:00
 default_executable:
 dependencies: []
-description: |+
-  This gem supposed to help you to forget about how to expose logging
-  facitilities to the code you write. Any time you want to log something,
-  simply do one of:
-     logger.debug("verbose debug information") #or
-     logger.warn("warning")  #or
-     logger.info("information you frequently want to see") #or
-     logger.error("errors") #or
-     logger.fatal("fatal errors")
-  and do not worry about where the '#logger' is and what it does at the moment,
-  you will have a chance to configure it in place where you confugure other things.
-  So you may focus on _what_ to put in the logging rather on how to set it up.
-  Later you may turn logging on for specific class or bunch of classes or in case
-  you have special logging demands for specific classes you also may specify it
-  in very simple way.
-  The simplest way to turn logging on for every class whose methods calls '#logger':
-      TaggedLogger.rules do
-        out_everything_to Logger.new(STDOUT)
-      end
-  or you may cook it in your special way:
-      TaggedLogger.rules do
-        out /.*/ do |level, tag, msg|
-          puts "#{level}-#{tag}: #{msg}"
-        end
-      end
-  Where 'tag' is the simple class name whose method calls '#logger'. Note,
-  you do not have to implement '#logger' method anywhere. It gets
-  automatically generated by specifying any of 'out' rules.
-    You may be even more picky about what and where to log. Imagine
-  you have 'Network' and 'Database' classes and you want to have
-  separate log files for them, it is easy:
-      TaggedLogger.rules do
-        out Network => Logger.new("network.log")
-        out Database => Logger.new("database.log")
-      end
-  In case you want to define common log for several classes:
-    TaggedLogger.rules do
-      out [Ftp, Http, Sockets] => Logger.new("network.log")
-    end
-  Or if you want to have all these classes showing up under common
-  tag 'Network' in standard output:
-      TaggedLogger.rules do
-        out_everything_to Logger.new(STDOUT)
-        rename [Ftp, Http, Sockets] => :Network
-      end
-  You may also use regular expressions in your rules:
-    TaggedLogger.rules do
-      out /Active::/ => Logger.new("active.log")
-    end
+description:
 email: fkocherga@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.html
+- README.markdown
 files:
 - .gitignore
 - MIT-LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
-- active.log
-- database.log
 - examples/one_log_per_classes.rb
 - examples/one_tag_per_classes.rb
 - examples/per_class_customization.rb
@@ -98,10 +35,11 @@ files:
 - examples/simplest_customization.rb
 - examples/simplest_usage.rb
 - lib/tagged_logger.rb
-- network.log
 - tagged_logger.gemspec
 - tagged_logger.rb
 - test/test.rb
+- todo.txt
+- README.html
 has_rdoc: true
 homepage: http://github.com/fkocherga/tagged_logger
 licenses: []

data/README.rdoc DELETED Viewed

@@ -1,63 +0,0 @@
-= TaggedLogger
-  Split your logging by using tags-based rules (tags are generated automatically)
-== What is it for?
-When you need to use logging for different code in different ways,
-here is help for you: create tags-based rules for logging. Tags are
-class names by default, so you do not have to specify them in
-+logger.info+, +logger.warn+ and similar calls. Rules are just code blocks,
-so any logging facility could be used underneath:  standard library
-+Logger+, +log4r+, writing to +STDOUT+ or something else.
-== Installation
-  $ sudo gem install tagged_logger --source=http://gemcutter.org
-== Usage
-    require 'rubygems'
-    require 'tagged_logger'
-    require 'logger'
-    #for class A the tag 'A' is used implicitly, no need to specify it
-    class A
-      def foo; logger.info("#{self.class}...".downcase); end
-    end
-    file_logger = Logger.new('my_log.log')
-    file_logger.formatter = lambda {|severity, datetime, progname, msg| "#{msg}"}
-    #If we want to have #logger in every class doing whatever we need
-    TaggedLogger.use_in_every_class do |level, tag, what|
-      file_logger.send(level, "#{tag}: #{what}\n")
-    end
-    A.new.foo #'A: a...' printed in 'my_log.log'
-    #Adding special logging for class A (or everything with tag 'A')
-    TaggedLogger.for_tag A do |level, tag, what|
-      STDOUT << "#{level}---#{tag}---#{what}\n"
-    end
-    A.new.foo #'A: a...' printed in 'my_log.log', 'info---A---a...' - in STDOUT
-    B = Class.new(A)
-    B.new.foo #'B: b...' printed in 'my_log.log', but not in STDOUT
-    #Rule for A and B says: logging within these classes happens with tag 'COMBINED':
-    TaggedLogger.replace_tags [A, B], :with => :COMBINED
-    A.new.foo #'COMBINED: a...' printed in 'my_log.log', but nothing in STDOUT
-    B.new.foo #'COMBINED: b...' printed in 'my_log.log'
-    #Adding special rule for 'COMBINED' tag
-    TaggedLogger.for_tag :COMBINED do |level, tag, what|
-      STDERR << "Oh my gosh!!! #{what}\n"
-    end
-    A.new.foo #'Oh my gosh!!! a...' printed in 'my_log.log' and in STDERR
-    B.new.foo #'Oh my gosh!!! b...' printed in 'my_log.log' and in STDERR
-    #Hope you've got the idea, do not hesitate to ask/fix me something...
-== License
-TaggedLogger is released under the MIT license.
-= Shortcumings
-Was not tested with log4r

data/active.log DELETED Viewed

	@@ -1,2 +0,0 @@
1	- # Logfile created on Sun Dec 20 19:27:33 -0600 2009 by /
2	- I, [2009-12-20T19:27:33.951440 #36852] INFO -- : Active::Base: foo

data/database.log DELETED Viewed

	@@ -1,2 +0,0 @@
1	- # Logfile created on Sun Dec 20 19:27:20 -0600 2009 by /
2	- I, [2009-12-20T19:27:20.352239 #36844] INFO -- : Database: foo

data/network.log DELETED Viewed

	@@ -1,2 +0,0 @@
1	- # Logfile created on Sun Dec 20 19:27:20 -0600 2009 by /
2	- I, [2009-12-20T19:27:20.356509 #36844] INFO -- : Network: foo