logbert 0.6.4 → 0.6.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c133267e75a816038c4abdafba21f850d4a0731f
-  data.tar.gz: 6bd905d93430880aa4889e11e4ceb063f1581673
+  metadata.gz: 26bafce2e48323c5a058c24fcb462e6502c09493
+  data.tar.gz: 69b57207d64eac6b5a7588f1fcec11efcf725de3
 SHA512:
-  metadata.gz: 26f685bcedaf8d2fbfec4dc5caff3f212d5e9a3c10d547f07c785a95497e9fa0ca7c2d02b4efbd7faaa721c4278def872b34001f829671131f7035a1e3084d83
-  data.tar.gz: be0035b051689de397e889f75a3777bbecd806ad99720ea5201ff937ed39ede1506838e4f23b6e1b9a2c6e2c8d87d90e4fdf61cae53915c973cf635a4abc2cda
+  metadata.gz: 5ce4a7daaa541567e830819e6e24d86b7cd2257cf13872d8cb0845a85888de23a4b46531e31798580403414566c37e910cc8345aeaf0a7f0388ab160df207522
+  data.tar.gz: dd8351a14e2440195f0591a277c2689e448957fd3005bc512f8affef7d1943e039aa4e266c0883ccb5a1aa7c8322c5c0be2b24ce63c07904f82cb45f9989b4a7

data/lib/logbert/formatters.rb

@@ -4,7 +4,7 @@ require 'logbert/message'
 module Logbert
   
   module Formatters
-    
+        
     class Formatter
       def format(msg)
         raise NotImplementedError
@@ -14,7 +14,20 @@ module Logbert
     class SimpleFormatter < Formatter
       def format(msg)
         level = msg.level.to_s.upcase.ljust(8)
-        "#{level} [time='#{msg.time}' pid='#{msg.pid}' logger='#{msg.logger}'] : #{msg.content}"
+        output = "#{level} [time='#{msg.time}' pid='#{msg.pid}' logger='#{msg.logger}'] : #{msg.content}"
+        if msg.exception
+          output = [output, "\n\nException information:\n", msg.exception.class, ": ", msg.exception.message, "\n"]
+
+          backtrace = backtrace = msg.exception.backtrace
+          if backtrace
+            output += [backtrace.join($/), "\n\n"]
+          else
+            output << "(Backtrace is unavailable)\n\n"
+          end
+          
+          output = output.join
+        end
+        return output
       end
     end
     

data/lib/logbert/levels.rb

@@ -21,75 +21,101 @@ module Logbert
     def to_s
       @name.to_s
     end
+    
+    def inspect
+      "Level(#{@name.inspect}, #{@value})"
+    end
   end
 
   # This class doubles as a mixin.  Bazinga!
   class LevelManager < Module
     
     def initialize
-      @name_to_level  = {}
-      @value_to_level = {}
+      @level_to_aliases = {}
 
       @quick_lookup   = {}
       
       Logbert::DefaultLevels.each{|name, value| self.define_level(name, value)}
+      self.alias_level :warn, :warning
     end
     
-    def names
-      @name_to_level.keys
-    end
-    
-    def values
-      @value_to_level.keys
-    end
-    
+
     def levels
-      @name_to_level.values
-    end    
+      @level_to_aliases.keys
+    end
 
+    def aliases_for(level)
+      level = self.level_for(level)
+      @level_to_aliases.fetch(level)
+    end
     
     def define_level(name, value)
-      unless name.instance_of?(Symbol) or name.instance_of?(String)
-        raise ArgumentError, "The Level's name must be a Symbol or a String"
-      end
+      raise ArgumentError, "The Level's name must implement #to_sym" unless name.respond_to? :to_sym
       raise ArgumentError, "The Level's value must be an Integer" unless value.is_a? Integer
       
-      # TODO: Verify that the name/value are not already taken
-      raise KeyError, "A Level with that name is already defined: #{name}" if @name_to_level.has_key? name
-      raise KeyError, "A Level with that value is already defined: #{value}" if @value_to_level.has_key? value
+      name = name.to_sym
+      
+      raise KeyError, "A Level with that name is already defined:  #{name}"  if @quick_lookup.has_key? name
+      raise KeyError, "A Level with that value is already defined: #{value}" if @quick_lookup.has_key? value
       
       level = Level.new(name, value)
 
-      @name_to_level[name]   = level
-      @value_to_level[value] = level
       @quick_lookup[name] = @quick_lookup[value] = @quick_lookup[level] = level
+      @level_to_aliases[level] = [name]
       
       self.create_logging_method(name)
       self.create_predicate_method(name, value)
+      
+      return level
     end
+    
+    
+    def alias_level(alias_name, level)
+      raise ArgumentError, "The Level alias must implement #to_sym: #{alias_name}" unless alias_name.respond_to? :to_sym
+      
+      alias_name = alias_name.to_sym
+      
+      preexisting_level = @quick_lookup[alias_name]
+      if preexisting_level
+        raise KeyError, "The alias is already taken: #{alias_name} -> #{preexisting_level}"
+      end
+      
+      level = self.level_for!(level, false)
 
+      @level_to_aliases[level] << alias_name
+      @quick_lookup[alias_name] = level
+      
+      alias_method alias_name, level.name
+      alias_method "#{alias_name}?", "#{level.name}?"
+      
+      return level
+    end
 
-    def [](x)
+
+    def level_for(x, allow_virtual_levels = true)
       @quick_lookup[x] or begin
         if x.is_a? Integer
-          # Return either the pre-defined level, or produce a virtual level.
-          level = @value_to_level[x] || Logbert::Level.new("LEVEL_#{x}".to_sym, x)
-          return level
-        elsif x.is_a? String
-          level = @name_to_level[x.to_sym]
+          return Logbert::Level.new("LEVEL_#{x}".to_sym, x) if allow_virtual_levels
+        elsif x.respond_to? :to_sym
+          level = @quick_lookup[x.to_sym]
           return level if level
         end
-        
-        raise KeyError, "No Level could be found for input: #{x}"
+
+        nil
       end
     end
-
+    
+    def level_for!(x, allow_virtual_levels = true)
+      self.level_for(x, allow_virtual_levels) or raise KeyError, "No Level could be found for input: #{x}"
+    end
+    
+    alias :[] :level_for
 
     protected
     
     def create_logging_method(level_name)
-      define_method level_name do |content = nil, &block|
-        self.log(level_name, content, &block)
+      define_method level_name do |*args, &block|
+        self.log(level_name, *args, &block)
       end
     end
     

data/lib/logbert/logger.rb

@@ -41,8 +41,18 @@ module Logbert
       self.factory.root
     end
     
-    def log(level, content = nil, &block)
-      message = Logbert::Message.create(self, @level_manager[level], content, &block)
+    def log(level, *args, &block)
+      content, options = self.prepare_message_args(*args, &block)
+      
+      exception = options[:exc_info]
+      if exception
+        # If the user passed in an exception, then use that one.
+        # Otherwise, check the magic $! variable to see if an
+        # exception is currently being handled.
+        exception = $! unless exception.is_a? Exception
+      end
+
+      message = Logbert::Message.create(self, @level_manager[level], exception, options, content, &block)
       handle_message(message)
     end
     
@@ -52,6 +62,24 @@ module Logbert
     end
     
     protected
+    
+    
+    # This method will be unnecessary once we upgrade to Ruby 2.x
+    def prepare_message_args(*args, &block)
+      if args.size == 0
+        return [nil, {}]
+      elsif args.size == 1
+        if block_given?
+          return [nil, args[0]]
+        else
+          return [args[0], {}]
+        end
+      elsif args.size == 2
+        return [args[0], args[1]]
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 0..2)"
+      end
+    end
 
     def handle_message(message)
       if message.level.value >= self.level.value

data/lib/logbert/message.rb

@@ -2,20 +2,22 @@
 module Logbert
   
   class Message
-    attr_reader :logger, :level, :time, :pid, :content_proc
+    attr_reader :logger, :level, :time, :pid, :exception, :options, :content_proc
     
-    def initialize(logger, level, time, pid, content = nil, &content_proc)
+    def initialize(logger, level, time, pid, exception, options, content = nil, &content_proc)
       @logger       = logger
       @level        = level
       @time         = time
       @pid          = pid
+      @exception    = exception
+      @options      = options
       
       @content      = content
       @content_proc = content_proc
     end
 
-    def self.create(logger, level, content = nil, &content_proc)
-      Message.new logger, level, Time.now, Process.pid, content, &content_proc
+    def self.create(logger, level, exception, options, content = nil, &content_proc)
+      Message.new logger, level, Time.now, Process.pid, exception, options, content, &content_proc
     end
 
     # Returns the content.  If the content has not been created yet,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logbert
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.6.13
 platform: ruby
 authors:
 - Brian Lauber