lager 1.1.0.1 → 1.1.2.1

data/README.md

@@ -4,66 +4,71 @@ Lager is a logging mixin.  It is designed to add class methods for logging, via
 
 Usage
 -----
-    require 'lager'
+```ruby
+require 'lager'
 
-    class Foo
-      extend Lager
-      log_to $stdout, :debug  # sets up @lager at the class layer
-      # ...
+class Foo
+  extend Lager
+  log_to $stdout, :debug  # sets up @lager at the class layer
+  # ...
+```
 
 Now, within Foo, you can use the class instance variable @lager for logging.
 
-      # ...
-      def self.bar(baz)
-        unless baz.is_a?(String)
-          @lager.debug { "baz #{baz} is a #{baz.class}, not a string" }
-        end
-      end
-      # ...
+```ruby
+  # ...
+  def self.bar(baz)
+    unless baz.is_a?(String)
+      @lager.debug { "baz #{baz} is a #{baz.class}, not a string" }
+    end
+  end
+  # ...
+```
 
 What about instance methods, you ask?  Well, you will need to assign @lager yourself, within #initialize.
 
-      # ...
-      def initialize
-        # set the instance layer's @lager to the class layer's @lager
-        @lager = self.class.lager
-        # now both layers are using the same instance
-      end
-
-      def do_something_complicated
-        @lager.debug { "about to do something complicated" }
-        # ...
-        @lager.debug { "whew! we made it!" }
-      end
-    end
+```ruby
+  # ...
+  def initialize
+    # set the instance layer's @lager to the class layer's @lager
+    @lager = self.class.lager
+    # now both layers are using the same instance
+  end
+
+  def do_something_complicated
+    @lager.debug { "about to do something complicated" }
+    # ...
+    @lager.debug { "whew! we made it!" }
+  end
+end
+```
 
 Everything under control
 ------------------------
 Right now, Foo is spewing debug messages everywhere:
 
-    Foo.bar(15)
-    f = Foo.new
-    f.do_something_complicated
-
-    [2013-07-05 15:14:52] DEBUG: baz 15 is a Fixnum, not a string
-    [2013-07-05 15:14:52] DEBUG: about to do something complicated
-    [2013-07-05 15:14:52] DEBUG: whew! we made it!
+```ruby
+Foo.bar(15)
+f = Foo.new
+f.do_something_complicated
 
+[2013-07-05 15:14:52] DEBUG: baz 15 is a Fixnum, not a string
+[2013-07-05 15:14:52] DEBUG: about to do something complicated
+[2013-07-05 15:14:52] DEBUG: whew! we made it!
+```
 
-This is because we set the default logging to :debug level, above:
+This is because we set the default logging to :debug level, above.  Let's calm things down a bit, shall we?
 
-    class Foo
-      extend Lager
-      log_to $stdout, :debug  # sets up @lager at the class layer
-
-Let's calm things down a bit, shall we?
-
-    Foo.log_level :warn
-    Foo.new.do_something_complicated
+```ruby
+Foo.log_level = :warn
+Foo.new.do_something_complicated
+```
 
 We can tell Foo to log to a file:
 
-    Foo.log_to '/tmp/foo.log'
+```ruby
+Foo.log_to '/tmp/foo.log'
+```
 
 Note that this will replace the class's Logger instance.  The old log level will be maintained unless you specify a new one.
 
@@ -76,14 +81,16 @@ Best practices
 
 For Logger, generally: use block invocation of message methods.
 
-    @lager.debug { "hi" }
-    # rather than
-    @lager.debug "hi"
+```ruby
+@lager.debug { "hi" }
+# rather than
+@lager.debug "hi"
 
-    # By using the first form, the block will not be evaluated unless we
-    # are logging at DEBUG level.
-    # If using the second form, the message is evaluated no matter the current
-    # log level.  This can be significant when logging complicated messages.
+# By using the first form, the block will not be evaluated unless we
+# are logging at DEBUG level.
+# If using the second form, the message is evaluated no matter the current
+# log level.  This can be significant when logging complicated messages.
+```
 
 Artifacts
 ---------
@@ -91,32 +98,55 @@ Artifacts
   * lager
   * log_to
   * log_level
-* By calling log_to, you introduce the class instance variable @lager
-* By assigning @lager within initialize, you introduce the instance variable @lager
+  * log_level=
+* By calling log_to, you introduce the *class instance variable* @lager
+* By assigning @lager within initialize, you introduce the *instance variable* @lager
 
 Now you have a unified interface for logging at both class and instance layers.
 
-    @lager.info { "So happy right now!" }
+```ruby
+  @lager.info { "So happy right now!" }
+```
 
 Use an existing Logger instance
 -------------------------------
 If your project already has an existing Logger, then you can set your class to use that Logger:
 
-    class Foo
-      extend Lager
-      log_to $LOG # the global Logger instance
-      # ...
-    end
+```ruby
+class Foo
+  extend Lager
+  log_to $LOG # the global Logger instance
+  # ...
+end
+```
 
 Of course, $LOG will have to have already been defined at requiretime.  You can set it the same way at runtime:
 
-    class Foo
-      extend Lager
-      log_to $stderr
-      # ...
-    end
+```ruby
+class Foo
+  extend Lager
+  log_to $stderr
+  # ...
+end
+
+# now, in an irb session or another file
+# where Project.log is your project's Logger:
+
+Foo.log_to Project.log
+```
+
+Inheritance
+-----------
+```ruby
+class Foo
+  extend Lager
+end
+
+class Bar < Foo
+end
 
-    # now, in an irb session or another file
-    # where Project.log is your project's Logger:
+# Bar will have Lager mixed in.  Its @lager is independent of Foo's.
+# You can set Bar's to Foo's
 
-    Foo.log_to Project.log
+Bar.log_to Foo.lager
+```

data/VERSION

@@ -1 +1 @@
-1.1.0.1
+1.1.2.1

data/lib/lager.rb

@@ -15,9 +15,6 @@ require 'logger'
 #   @lager.debug { "example log message" }
 # end
 #
-# Note that using the block invocation means that the block contents are
-# not evaluated if the log level is above the message level.
-#
 # Make sure to call log_to within the class definition, so that class methods
 # will already have @lager defined at requiretime.
 #
@@ -30,12 +27,6 @@ require 'logger'
 #   @lager = self.class.lager
 # end
 #
-# Outside of initialize or a call to log_to within the class definition,
-# you should only ever call the message methods: debug, info, warn, error,
-# and fatal within your class code.
-#
-# Let the destination and log level be managed from outside.
-#
 module Lager
   def self.version
     file = File.expand_path('../../VERSION', __FILE__)
@@ -59,7 +50,7 @@ module Lager
       line << "(#{progname})" if progname
       line << " #{msg}\n"
     }
-    log_level = level
+    self.log_level = level
     dest # don't expose @lager here
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lager
 version: !ruby/object:Gem::Version
-  version: 1.1.0.1
+  version: 1.1.2.1
   prerelease: 
 platform: ruby
 authors: