logbert 0.6.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c133267e75a816038c4abdafba21f850d4a0731f
+  data.tar.gz: 6bd905d93430880aa4889e11e4ceb063f1581673
+SHA512:
+  metadata.gz: 26f685bcedaf8d2fbfec4dc5caff3f212d5e9a3c10d547f07c785a95497e9fa0ca7c2d02b4efbd7faaa721c4278def872b34001f829671131f7035a1e3084d83
+  data.tar.gz: be0035b051689de397e889f75a3777bbecd806ad99720ea5201ff937ed39ede1506838e4f23b6e1b9a2c6e2c8d87d90e4fdf61cae53915c973cf635a4abc2cda

data/lib/logbert/formatters.rb

@@ -0,0 +1,41 @@
+
+require 'logbert/message'
+
+module Logbert
+  
+  module Formatters
+    
+    class Formatter
+      def format(msg)
+        raise NotImplementedError
+      end
+    end
+    
+    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}"
+      end
+    end
+    
+    
+    class ProcFormatter < Formatter
+      attr_accessor :proc
+
+      def initialize(&block)
+        raise ArgumentError, "ProcFormatter must be initialized with a block" unless block_given?
+        @proc = block
+      end
+      
+      def format(msg)
+        @proc.call msg
+      end
+    end
+    
+    def self.fmt(&block)
+      ProcFormatter.new(&block)
+    end
+
+  end
+end
+

data/lib/logbert/handlers.rb

@@ -0,0 +1,45 @@
+
+require 'logbert/formatters'
+
+module Logbert
+  module Handlers
+    
+        
+    class BaseHandler
+      
+      def formatter
+        @formatter ||= Logbert::Formatters::SimpleFormatter.new
+      end
+      
+      def formatter=(value)
+        @formatter = value
+      end
+
+      def publish(message)
+        emit self.formatter.format(message)
+      end
+      
+      
+      def emit(output)
+        raise NotImplementedError
+      end
+
+    end
+    
+    
+    class StreamHandler < BaseHandler
+      attr_accessor :stream
+      
+      def initialize(stream = $stderr)
+        @stream = stream
+      end
+      
+      def emit(output)
+        @stream.puts output
+      end
+
+    end
+
+
+  end
+end

data/lib/logbert/levels.rb

@@ -0,0 +1,106 @@
+
+module Logbert
+
+  DefaultLevels = {
+    debug:    100,
+    info:     200,
+    warning:  300,
+    error:    400,
+    fatal:    500,
+  }
+
+
+  class Level
+    attr_reader :name, :value
+    
+    def initialize(name, value)
+      @name  = name
+      @value = value
+    end
+    
+    def to_s
+      @name.to_s
+    end
+  end
+
+  # This class doubles as a mixin.  Bazinga!
+  class LevelManager < Module
+    
+    def initialize
+      @name_to_level  = {}
+      @value_to_level = {}
+
+      @quick_lookup   = {}
+      
+      Logbert::DefaultLevels.each{|name, value| self.define_level(name, value)}
+    end
+    
+    def names
+      @name_to_level.keys
+    end
+    
+    def values
+      @value_to_level.keys
+    end
+    
+    def levels
+      @name_to_level.values
+    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 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
+      
+      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
+      
+      self.create_logging_method(name)
+      self.create_predicate_method(name, value)
+    end
+
+
+    def [](x)
+      @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 level if level
+        end
+        
+        raise KeyError, "No Level could be found for input: #{x}"
+      end
+    end
+
+
+    protected
+    
+    def create_logging_method(level_name)
+      define_method level_name do |content = nil, &block|
+        self.log(level_name, content, &block)
+      end
+    end
+    
+    def create_predicate_method(level_name, level_value)
+      define_method "#{level_name}?" do
+         self.level.value <= level_value
+      end
+    end
+
+
+  end
+
+
+end

data/lib/logbert/logger.rb

@@ -0,0 +1,68 @@
+
+require 'logbert/message'
+require 'logbert/handlers'
+
+module Logbert
+  
+  class Logger
+    
+    attr_reader :factory, :level_manager, :name, :handlers
+    
+    def initialize(factory, level_manager, name)
+      @factory       = factory
+      @level_manager = level_manager
+
+      @name     = name.dup.freeze
+      @handlers = []
+    end
+    
+    def level_inherited?
+      !!@level
+    end
+    
+    def level
+      @level || self.parent.level
+    end
+    
+    def level=(x)
+      @level = @level_manager[x]
+    end
+
+
+    def parent
+      unless @parent_defined
+        @parent = @factory.parent_for(self)
+        @parent_defined = true
+      end
+      return @parent
+    end
+
+    def root
+      self.factory.root
+    end
+    
+    def log(level, content = nil, &block)
+      message = Logbert::Message.create(self, @level_manager[level], content, &block)
+      handle_message(message)
+    end
+    
+    
+    def to_s
+      @name
+    end
+    
+    protected
+
+    def handle_message(message)
+      if message.level.value >= self.level.value
+        @handlers.each{|h| h.publish message}
+      end
+
+      p = self.parent
+      p.handle_message(message) if p
+    end
+
+  end
+
+end
+

data/lib/logbert/logger_factory.rb

@@ -0,0 +1,44 @@
+
+require 'logbert/naming'
+require 'logbert/logger'
+require 'logbert/levels'
+
+module Logbert
+
+  class LoggerFactory
+    
+    attr_reader :level_manager
+    
+    def initialize(level_manager = LevelManager.new)
+      @inventory = {}
+      @level_manager  = level_manager
+      self.root.level = @level_manager[:warning]
+    end
+    
+    def [](name_or_module)
+      name = Logbert.name_for(name_or_module)
+      @inventory[name] ||= begin
+        l = Logger.new(self, @level_manager, name)
+        l.extend @level_manager
+      end
+    end
+    
+    def root
+      @root ||= self['']
+    end
+    
+    def parent_for(logger)
+      n = logger.name
+      unless n.empty?
+        components = Logbert.split_name(n)
+        components.pop
+        parent_name = components.join(Logbert::NameSeparator)
+        return self[parent_name]
+      end
+    end
+
+  end
+
+end
+
+

data/lib/logbert/message.rb

@@ -0,0 +1,37 @@
+
+module Logbert
+  
+  class Message
+    attr_reader :logger, :level, :time, :pid, :content_proc
+    
+    def initialize(logger, level, time, pid, content = nil, &content_proc)
+      @logger       = logger
+      @level        = level
+      @time         = time
+      @pid          = pid
+      
+      @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
+    end
+
+    # Returns the content.  If the content has not been created yet,
+    # then call @content_proc and save the value.
+    def content
+      @content ||= begin
+        if @content_proc
+          @content_proc.call.to_s
+        else
+          ""
+        end
+      end
+    end
+
+  end
+  
+  
+end
+

data/lib/logbert/naming.rb

@@ -0,0 +1,20 @@
+
+module Logbert
+  
+  NameSeparator = "/"
+
+  def self.split_name(name)
+    name.split(Logbert::NameSeparator).reject{|n| n.empty?}
+  end
+
+  def self.name_for(n)
+    if n.is_a? Module
+      n.name.gsub("::", Logbert::NameSeparator)
+    else
+      Logbert.split_name(n.to_s).join(Logbert::NameSeparator)
+    end
+  end
+
+end
+
+

data/lib/logbert.rb

@@ -0,0 +1,20 @@
+
+require 'logbert/levels'
+require 'logbert/logger_factory'
+
+module Logbert
+
+  def self.factory
+    @factory ||= LoggerFactory.new
+  end
+
+  def self.[](name)
+    self.factory[name]
+  end
+  
+  def self.root
+    self.factory.root
+  end
+
+end
+

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: logbert
+version: !ruby/object:Gem::Version
+  version: 0.6.4
+platform: ruby
+authors:
+- Brian Lauber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-14 00:00:00.000000000 Z
+dependencies: []
+description: Change your logging behaviors without mucking with your code!
+email: constructible.truth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/logbert/formatters.rb
+- lib/logbert/handlers.rb
+- lib/logbert/levels.rb
+- lib/logbert/logger.rb
+- lib/logbert/logger_factory.rb
+- lib/logbert/message.rb
+- lib/logbert/naming.rb
+- lib/logbert.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Logging for winners.
+test_files: []