extended_logger 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f455250170001f45e0124012bea062f08d8d072
-  data.tar.gz: 783a45d09ed579227e8b343e3cd3732fae593fab
+  metadata.gz: 829c2ba09350eb621bb0694a0c099c7b392edf20
+  data.tar.gz: 43f5a2da899103fd2d42147909723229571a8d8c
 SHA512:
-  metadata.gz: b5e3b1f15f2f8d7caa9416cc4c58e76296278daec801a54444203ac47b6685ec54961e7cfa1752f1b5fd6ee322d3a709701dfe892172ef41e5c64a4be8a1bc89
-  data.tar.gz: 3df9a339830cf81d580f610da7fa88053c7b30cb559d960759ed709b56c28d25e7abc3482d3bed3ddacf0794091a6a320501b6bb7c19e4e75093bdfa982d3411
+  metadata.gz: 5c1b55af38672df94b92523b188bf26c36d97e333a225aed93d33c2901a043a0fab5e291749ecfdd91f3fca86e36fec9fd90cbe650e6039ab65cfb181026bd53
+  data.tar.gz: ee6f7448f2866dc7a4f5f23e6c92bec98cdbbd9ca34dc96efc93336961a68d2731fc29d7826481b5d092206f1e42c31fe4c5af67f6671232a7ecaf6ea8658d22

data/lib/extended_logger.rb

@@ -1,10 +1,15 @@
-require 'logger'
+require 'English'
 require 'time'
 
-require 'extended_logger/color_scheme'
-require 'extended_logger/configure_levels'
-require 'extended_logger/formatter'
-require 'extended_logger/logger_substitute'
-require 'extended_logger/per_class_logging'
-
-require 'extended_logger/extended_logger'
+require_relative './extended_logger/color_scheme'
+require_relative './extended_logger/defaults'
+require_relative './extended_logger/define'
+require_relative './extended_logger/extended_logger'
+require_relative './extended_logger/level'
+require_relative './extended_logger/level/set'
+require_relative './extended_logger/message'
+require_relative './extended_logger/rule'
+require_relative './extended_logger/serializer'
+require_relative './extended_logger/serializer/text_formatter'
+require_relative './extended_logger/sink'
+require_relative './extended_logger/verbosity_threshold'

data/lib/extended_logger/color_scheme.rb

@@ -1,146 +1,118 @@
 class ExtendedLogger
   class ColorScheme
-    attr_reader :map
+    def self.build values=nil
+      values ||= {}
 
-    def initialize map
-      @map = map
+      instance = new
+      Palette.apply values, instance
+      instance
     end
 
-    def self.build symbol_map
-      code_map = {}
+    def colorize message
+      value = get message.level.name
+      message.prose = value.colorize message.prose
+    end
 
-      symbol_map.each do |label, (fg_sym, bg_sym)|
-        fg = Colors.index fg_sym
-        bg = Colors.index bg_sym
+    def get level_name
+      table[level_name]
+    end
+    alias_method :[], :get
 
-        code_map[label] = [fg, bg]
-      end
+    def reset
+      "\e[0m"
+    end
 
-      new code_map
+    def set level_name, fg: nil, bg: nil
+      value = get level_name
+      value.fg = fg if fg
+      value.bg = bg if bg
     end
 
-    def color_code code
-      if code
-        code.to_s 16
-      else
-        '?'.freeze
+    def table
+      @table ||= Hash.new do |hash, level_name|
+        hash[level_name] = Value.new
       end
     end
 
-    def colorize severity, text
-      text = text.dup
+    None = self.new
 
-      fg, bg = map[severity]
+    module Palette
+      def self.apply values, color_scheme
+        values.each do |level_name, values|
+          values = { :fg => values } if values.is_a? Symbol
 
-      if bg
-        if bg > 8
-          text.insert 0, "\e[4#{bg - 8}m"
-        else
-          text.insert 0, "\e[4#{bg}m"
-        end
-      end
+          values.each_key do |target|
+            color_name = values[target]
+            values[target] = Palette.get color_name
+          end
 
-      if fg
-        if fg > 8
-          text.insert 0, "\e[1;3#{fg - 8}m"
-        else
-          text.insert 0, "\e[0;3#{fg}m"
+          color_scheme.set level_name, **values
         end
       end
 
-      if fg or bg
-        text << "\e[0m"
+      def self.get name
+        names.index name
       end
 
-      text
+      def self.names
+        %i(
+          black
+          red
+          green
+          brown
+          blue
+          magenta
+          cyan
+          gray
+          dark_gray
+          bright_red
+          bright_green
+          yellow
+          bright_blue
+          bright_magenta
+          bright_cyan
+          white
+        )
+      end
     end
 
-    def dump
-      output = ''.encode 'US-ASCII'
+    Value = Struct.new :fg, :bg do
+      def colorize prose
+        return prose if fg.nil? and bg.nil?
 
-      map.each do |level, (fg, bg)|
-        fg_code = color_code fg
-        bg_code = color_code bg
-
-        output << ',' unless output.empty?
-        output << "#{level}=#{fg_code};#{bg_code}"
+        new_prose = String.new
+        new_prose << escape_code
+        new_prose << prose
+        new_prose << reset
+        new_prose
       end
 
-      output
-    end
-
-    def levels
-      map.keys
-    end
+      def escape_code
+        string = String.new "\e["
 
-    def self.decode code
-      return if code == '?'.freeze
-      code.to_i 16
-    end
-
-    def self.load data
-      map = {}
+        if fg
+          brightness, fg_color = fg.divmod 8
+          string << brightness.to_s
+          string << ';3'
+          string << fg_color.to_s
+        end
 
-      values = data.split ','.freeze
+        if bg
+          string << ';' if fg
 
-      values.each do |assignment|
-        match_data = AssignmentPattern.match assignment
+          _, bg_color = bg.divmod 8
+          string << '4'
+          string << bg_color.to_s
+        end
 
-        label = match_data[:label]
-        fg = decode match_data[:fg_code]
-        bg = decode match_data[:bg_code]
+        string << 'm'
 
-        map[label] = [fg, bg]
+        string
       end
 
-      new map
-    end
-
-    def self.resolve input
-      case input
-      when String then self.load input
-      when true then Default
-      else raise ArgumentError, "Cannot resolve color scheme for #{input.inspect}"
+      def reset
+        "\e[0m"
       end
     end
-
-    AssignmentPattern = %r{\A
-      (?<label>[_A-Z]+)
-      =
-      (?<fg_code>[?[:xdigit:]])+
-      ;
-      (?<bg_code>[?[:xdigit:]]+)\z
-    }nx
-
-    Colors = %i(
-      black
-      red
-      green
-      brown
-      blue
-      magenta
-      cyan
-      gray
-
-      dark_gray
-      bright_red
-      bright_green
-      yellow
-      bright_blue
-      bright_magenta
-      bright_cyan
-      white
-    )
-
-    Default = self.build(
-      'DEBUG' => [:cyan, nil],
-      'INFO' => [nil, nil],
-      'WARN' => [:brown, nil],
-      'ERROR' => [:red, nil],
-      'FATAL' => [:white, :red],
-      'ANY' => [:white, :blue],
-    )
-
-    Null = self.new Hash.new
   end
 end

data/lib/extended_logger/controls.rb

@@ -1,48 +1,221 @@
+  require 'logger'
+
 class ExtendedLogger
   module Controls
     module ColorSchemes
-      def self.normal_verbose
-        color_scheme = ExtendedLogger::ColorScheme.build(
-          'NORMAL' => [:gray, :none],
-          'VERBOSE' => [:none, :gray],
+      def self.example
+        ColorScheme.build(
+          :verbose => { :fg => :black, :bg => :white },
+          :normal => { :fg => :white, :bg => :black },
         )
       end
+
+      module None
+        def self.value
+          ColorScheme::None
+        end
+      end
     end
 
-    module Loggers
-      class NormalVerbose < ExtendedLogger
-        self.levels = %w(VERBOSE NORMAL)
+    module Formatters
+      module Plain
+        def self.value
+          -> message do
+            "#{message.level} -- #{message.prose}"
+          end
+        end
+      end
+    end
+
+    module Label
+      def self.value
+        'SomeClass'
+      end
+    end
+
+    module Levels
+      def self.ruby_logger
+        Set.ruby_logger.get :info
+      end
+
+      def self.value label=nil
+        label ||= :normal
+        Set.get label
+      end
+
+      module Names
+        def self.ruby_logger
+          %i(debug info warn error fatal)
+        end
+
+        def self.value
+          %i(verbose normal)
+        end
+      end
+
+      module Set
+        def self.get name
+          example[name]
+        end
+
+        def self.ruby_logger
+          names = Names.ruby_logger
+          Level::Set.build names
+        end
+
+        def self.example
+          names = Names.value
+          Level::Set.build names, :default => :normal
+        end
+      end
+    end
+
+    class Logger < ExtendedLogger.define
+      def self.example device=nil
+        device ||= StringIO.new
+
+        instance = build device
+        instance.clock = Time::Clock
+        instance
       end
     end
 
     module Messages
-      def self.multiline
-        "crcrlf\r\r\n" +
-        "crlf\r\n" +
-        "cr\r" +
-        "lf\n" +
-        "\n\n" +
-        " \n" +
-        "\t\n" +
-        " \t\n" +
-        "\n"
+      def self.example prose: nil, level: nil, label: nil, time: nil
+        prose ||= Prose.example
+        level ||= Levels.value
+        time ||= Time.reference
+
+        if prose.is_a? Proc
+          block = prose
+        else
+          block = ->{ prose }
+        end
+
+        Message.new block, level, time, label
+      end
+
+      module Label
+        def self.value label=nil
+          label ||= Control::Label.value
+
+          Messages.example label: label
+        end
+      end
+
+      module RubyLogger
+        def self.value label=nil
+          level = Level.new :info
+
+          Messages.example level: level, label: label
+        end
       end
     end
 
     module Output
-      def self.multiline
-        <<-TEXT
-N, [2000-01-01##{$$}] NORMAL -- : crcrlf\\r\\r\\n
-N, [2000-01-01##{$$}] NORMAL -- : crlf\\r\\n
-N, [2000-01-01##{$$}] NORMAL -- : cr\\r
-N, [2000-01-01##{$$}] NORMAL -- : lf\\n
-N, [2000-01-01##{$$}] NORMAL -- : \\n
-N, [2000-01-01##{$$}] NORMAL -- : \\n
-N, [2000-01-01##{$$}] NORMAL -- :  \\n
-N, [2000-01-01##{$$}] NORMAL -- : \\t\\n
-N, [2000-01-01##{$$}] NORMAL -- :  \\t\\n
-N, [2000-01-01##{$$}] NORMAL -- : \\n
-        TEXT
+      def self.value prose=nil
+        prose ||= Prose.example
+        "NORMAL -- #{prose}\n"
+      end
+
+      module Colorized
+        def self.value prose=nil
+          prose ||= Prose.example
+          colorized_prose = "\e[1;37;40m#{prose}\e[0m"
+
+          Output.value colorized_prose
+        end
+      end
+
+      module MultipleLines
+        def self.value
+          "NORMAL -- Multiple\nNORMAL -- line\nNORMAL -- message\n"
+        end
+      end
+
+      module RubyLogger
+        def self.log_format
+          @log_format ||= ::Logger::Formatter.new
+        end
+
+        def self.value progname=nil
+          severity = 'INFO'
+          time = Time::Clock.now
+          message = Prose.example
+
+          log_format.(severity, time, progname, message)
+        end
+      end
+
+      module RuleApplied
+        def self.value
+          prose = Prose.example
+          prose = prose.upcase
+
+          Output.value prose
+        end
+      end
+    end
+
+    module Prose
+      def self.example
+        SingleLine.value
+      end
+
+      module EscapeCodes
+        def self.value
+          "\t\r"
+        end
+      end
+
+      module MultipleLines
+        def self.value
+          "Multiple\nline\nmessage"
+        end
+      end
+
+      module SingleLine
+        def self.value
+          "Some log message"
+        end
+      end
+    end
+
+    module Rule
+      class Example
+        include ExtendedLogger::Rule
+
+        def call message
+          message.prose = message.prose.upcase
+          message
+        end
+      end
+    end
+
+    module Sink
+      def self.example device=nil, format: nil, rules: nil
+        format ||= Controls::Formatters::Plain.value
+        device ||= StringIO.new
+        levels = Controls::Levels::Set.example
+
+        ExtendedLogger::Sink.build(
+          device,
+          format: format,
+          levels: levels,
+          rules: rules,
+        )
+      end
+    end
+
+    module Time
+      module Clock
+        def self.now
+          Time.reference
+        end
+      end
+
+      def self.reference
+        ::Time.new 2000
       end
     end
   end

data/lib/extended_logger/defaults.rb

@@ -0,0 +1,21 @@
+class ExtendedLogger
+  module Defaults
+    def self.color_scheme
+      ColorScheme::None
+    end
+
+    def self.log_format
+      @log_format ||= -> message do
+        time = message.time.strftime '%Y-%m-%dT%H:%M:%S.%6N'
+        level = message.level.to_s.rjust 5
+
+        "#{message.level.abbreviation}, [#{time} ##{$$}] #{level} -- #{message.label}: #{message.prose}"
+      end
+    end
+
+    def self.levels
+      level_names = %i(debug info warn error fatal)
+      Level::Set.build level_names
+    end
+  end
+end

data/lib/extended_logger/define.rb

@@ -0,0 +1,37 @@
+class ExtendedLogger
+  def self.define levels=nil, **defaults
+    levels ||= Defaults.levels
+
+    subclass = Class.new self
+    Define.(subclass, levels)
+    subclass
+  end
+
+  class Define
+    attr_reader :levels
+    attr_reader :subclass
+
+    def initialize subclass, levels, **defaults
+      @levels = levels
+      @subclass = subclass
+    end
+
+    def self.call *arguments
+      instance = new *arguments
+      instance.()
+    end
+
+    def call
+      levels = self.levels
+      subclass.send :define_method, :levels do levels end
+
+      levels.each do |level|
+        method_name = level.name
+
+        subclass.send :define_method, method_name do |*arguments, &block|
+          add level, *arguments, &block
+        end
+      end
+    end
+  end
+end

data/lib/extended_logger/extended_logger.rb

@@ -1,46 +1,56 @@
 class ExtendedLogger
-  include LoggerSubstitute
-  extend PerClassLogging
+  attr_writer :clock
+  attr_accessor :label
+  attr_writer :level
+  attr_reader :sink
 
-  attr_accessor :always_interpolate
-  attr_writer :color_scheme
-
-  def self.build io, always_interpolate: nil, color_scheme: nil
-    instance = new io
-
-    instance.always_interpolate = true if always_interpolate
+  def initialize sink
+    @sink = sink
+  end
 
-    if color_scheme and io.tty?
-      color_scheme = ColorScheme.resolve color_scheme
-      instance.color_scheme = color_scheme
-    end
+  def self.build *arguments
+    sink = Sink.build *arguments
 
+    instance = new sink
     instance
   end
 
-  def add severity, *, &block
-    if always_interpolate and severity < level
-      block.() if block
-    end
+  def add level, prose=nil, label: nil, &block
+    block ||= ->{ prose }
+    label ||= self.label
+
+    time = clock.now
 
-    super
+    message = Message.new block, level, time, label
+
+    sink << message
+  end
+
+  def clock
+    @clock ||= Time
   end
 
-  def color_scheme
-    @color_scheme ||= ColorScheme::Null
+  def device
+    sink.device
   end
 
-  def format severity, *arguments
-    formatted_message = super
-    color_scheme.colorize severity, formatted_message
+  def level
+    @level ||= levels.default
   end
 
-  def self.levels= levels
-    ConfigureLevels.configure_levels self, levels
+  def level= reference
+    @level = levels.resolve reference
   end
 
-  # ExtendedLogger::Logger can be used in place of ::Logger
-  class Logger < ExtendedLogger
-    self.levels = %w(DEBUG INFO WARN ERROR FATAL)
+  module Assertions
+    def nothing_written?
+      written? ''
+    end
+
+    def written? expected_data
+      device.rewind
+      actual_data = device.read
+      actual_data == expected_data
+    end
   end
 end

data/lib/extended_logger/level.rb

@@ -0,0 +1,25 @@
+class ExtendedLogger
+  class Level < Struct.new :name, :prev, :next
+    include Comparable
+
+    def <=> other
+      self.ordinal <=> other.ordinal
+    end
+
+    def abbreviation
+      label[0]
+    end
+
+    def ordinal
+      @ordinal ||= if prev then prev.ordinal + 1 else 0 end
+    end
+
+    def label
+      @label ||= name.to_s.upcase
+    end
+
+    def to_s
+      label
+    end
+  end
+end

data/lib/extended_logger/level/set.rb

@@ -0,0 +1,64 @@
+class ExtendedLogger
+  class Level
+    class Set
+      attr_reader :default_name
+      attr_reader :names
+
+      def initialize names, default_name=nil
+        @default_name = default_name
+        @names = names
+      end
+
+      def self.build names, default: nil
+        default ||= names.first
+        new names, default
+      end
+
+      def == other
+        default_name == other.default_name and
+          names == other.names
+      end
+
+      def build_index
+        hash = {}
+
+        names.reduce nil do |previous_level, name|
+          level = Level.new name
+
+          level.prev = previous_level
+          previous_level.next = level if previous_level
+
+          hash[name] = level
+          level
+        end
+
+        hash
+      end
+
+      def default
+        get default_name
+      end
+
+      def each &block
+        index.each_value &block
+      end
+
+      def get name
+        index[name]
+      end
+      alias_method :[], :get
+
+      def index
+        @index ||= build_index
+      end
+
+      def resolve reference
+        if reference.is_a? Symbol
+          get reference
+        else
+          get reference.name
+        end
+      end
+    end
+  end
+end

data/lib/extended_logger/message.rb

@@ -0,0 +1,13 @@
+class ExtendedLogger
+  Message = Struct.new :block, :level, :time, :label do
+    attr_writer :prose
+
+    def inspect
+      "#<ExtendedLogger::Message prose=#{prose.inspect}, level=#{level}, time=#{time.iso8601}, label=#{label.inspect}>"
+    end
+
+    def prose
+      @prose ||= block.()
+    end
+  end
+end

data/lib/extended_logger/rule.rb

@@ -0,0 +1,13 @@
+class ExtendedLogger
+  module Rule
+    def call _
+      fail "Not implemented"
+    end
+
+    module Assertions
+      def filter? message
+        if self.(message) then false else true end
+      end
+    end
+  end
+end

data/lib/extended_logger/serializer.rb

@@ -0,0 +1,44 @@
+class ExtendedLogger
+  class Serializer
+    attr_writer :color_scheme
+    attr_reader :log_format
+
+    def initialize log_format
+      @log_format = log_format
+    end
+
+    def self.build log_format: nil, color_scheme: nil
+      log_format ||= Defaults.log_format
+
+      instance = new log_format
+      instance.color_scheme = color_scheme if color_scheme
+      instance
+    end
+
+    def call message
+      messages = format_text message
+
+      messages.reduce String.new do |string, message|
+        color_scheme.colorize message
+
+        string << log_format.(message)
+        string << "\n"
+        string
+      end
+    end
+
+    def color_scheme
+      @color_scheme ||= ColorScheme::None
+    end
+
+    def format_text message
+      lines = TextFormatter.(message.prose)
+
+      lines.map do |line|
+        line_message = message.dup
+        line_message.prose = line
+        line_message
+      end
+    end
+  end
+end

data/lib/extended_logger/serializer/text_formatter.rb

@@ -0,0 +1,37 @@
+class ExtendedLogger
+  class Serializer
+    class TextFormatter
+      attr_reader :prose
+
+      def initialize prose
+        @prose = prose
+      end
+
+      def self.call prose
+        instance = new prose
+        instance.()
+      end
+
+      def call
+        return %w(<empty message>) if prose.nil? or prose.empty?
+
+        lines.map do |line|
+          line.chomp! if line.match %r{(?<!\r)\n}
+
+          if line.empty?
+            "\\n"
+          else
+            line = line.inspect
+            line.slice! 0, 1
+            line.slice! -1, 1
+            line
+          end
+        end
+      end
+
+      def lines
+        @lines ||= prose.each_line $INPUT_RECORD_SEPARATOR
+      end
+    end
+  end
+end

data/lib/extended_logger/sink.rb

@@ -0,0 +1,50 @@
+class ExtendedLogger
+  class Sink
+    attr_reader :device
+    attr_reader :levels
+    attr_writer :rules
+    attr_reader :serializer
+
+    def initialize device, levels, serializer
+      @device = device
+      @levels = levels
+      @serializer = serializer
+    end
+
+    def self.build device=nil, format: nil, levels: nil, rules: nil, serializer: nil
+      device ||= $stderr
+      levels ||= Defaults.levels
+      serializer ||= Serializer.build log_format: format
+
+      instance = new device, levels, serializer
+      instance.rules = rules if rules
+      instance
+    end
+
+    def << message
+      message = apply_rules message
+
+      verbosity_threshold.(message) or return
+
+      output = serializer.(message)
+
+      device.write output
+    end
+
+    def apply_rules message
+      rules.reduce message do |message, rule|
+        rule.(message) or return
+      end
+    end
+
+    def rules
+      @rules ||= []
+    end
+
+    def verbosity_threshold
+      @verbosity_threshold ||= VerbosityThreshold.new levels.default
+    end
+
+    Assertions = ExtendedLogger::Assertions
+  end
+end

data/lib/extended_logger/verbosity_threshold.rb

@@ -0,0 +1,29 @@
+class ExtendedLogger
+  class VerbosityThreshold
+    include Rule
+
+    attr_accessor :level
+
+    def initialize level
+      @level = level
+    end
+
+    def call message
+      if message.level >= level
+        message
+      end
+    end
+
+    def lower
+      if level.prev
+        self.level = level.prev
+      end
+    end
+
+    def raise
+      if level.next
+        self.level = level.next
+      end
+    end
+  end
+end

metadata

@@ -1,19 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: extended_logger
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Nathan Ladd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-16 00:00:00.000000000 Z
-dependencies: []
-description: 'An extended logger that provides a (mostly) substitutable alternative
-  to ruby''s built in +Logger+ class. A number of useful extensions are provided,
-  including colorized output, the ability to define custom log levels, multi-line
-  formatting, and per-class logging.
+date: 2016-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'A logging library that provides more feature''s than ruby''s built in
+  logger; namely per-class logging, color schemes, and custom log levels.
 
 '
 email: nathanladd+github@gmail.com
@@ -23,12 +35,18 @@ extra_rdoc_files: []
 files:
 - lib/extended_logger.rb
 - lib/extended_logger/color_scheme.rb
-- lib/extended_logger/configure_levels.rb
 - lib/extended_logger/controls.rb
+- lib/extended_logger/defaults.rb
+- lib/extended_logger/define.rb
 - lib/extended_logger/extended_logger.rb
-- lib/extended_logger/formatter.rb
-- lib/extended_logger/logger_substitute.rb
-- lib/extended_logger/per_class_logging.rb
+- lib/extended_logger/level.rb
+- lib/extended_logger/level/set.rb
+- lib/extended_logger/message.rb
+- lib/extended_logger/rule.rb
+- lib/extended_logger/serializer.rb
+- lib/extended_logger/serializer/text_formatter.rb
+- lib/extended_logger/sink.rb
+- lib/extended_logger/verbosity_threshold.rb
 homepage: https://github.com/ntl/extended-logger
 licenses:
 - MIT

data/lib/extended_logger/configure_levels.rb

@@ -1,35 +0,0 @@
-class ExtendedLogger
-  module ConfigureLevels
-    def self.configure_levels target, labels
-      levels = []
-
-      labels.each_with_index do |label, severity|
-        level_name = label.upcase
-        levels << level_name
-
-        configure_level target, level_name, severity
-      end
-
-      target.const_set :UNKNOWN, labels.size
-
-      levels.each &:freeze
-      levels.freeze
-
-      target.send :define_singleton_method, :levels do levels end
-    end
-
-    def self.configure_level target, level_name, severity
-      method_name = level_name.downcase
-
-      target.send :define_method, "#{method_name}?" do
-        level <= severity
-      end
-
-      target.send :define_method, method_name do |progname=nil, &block|
-      add severity, nil, progname, &block
-      end
-
-      target.const_set level_name, severity
-    end
-  end
-end

data/lib/extended_logger/formatter.rb

@@ -1,49 +0,0 @@
-class ExtendedLogger
-  class Formatter
-    BlankLine = /\A[[:blank:]]*\z/n
-    LineEnding = /[[:blank:]]*\r*[\r\n]/n
-    Separator = "\n".freeze
-
-    attr_accessor :internal_formatter
-
-    def initialize internal_formatter
-      @internal_formatter = internal_formatter
-    end
-
-    def self.build
-      internal_formatter = ::Logger::Formatter.new
-      new internal_formatter
-    end
-
-    def call *arguments
-      format internal_formatter, *arguments
-    end
-
-    def datetime_format= format
-      internal_formatter.datetime_format = format
-    end
-
-    def format formatter, *arguments, message
-      message = message.to_s
-      message = message.dup
-
-      if BlankLine.match message.to_s
-        formatter.(*arguments, '(empty log message)'.freeze)
-      else
-        message.gsub! LineEnding do |line_ending|
-          quoted = line_ending.inspect[1...-1]
-          quoted << Separator
-          quoted
-        end
-
-        lines = message.split Separator
-
-        lines.reduce String.new do |output, line|
-          formatted_line = formatter.(*arguments, line)
-          output << formatted_line
-          output
-        end
-      end
-    end
-  end
-end

data/lib/extended_logger/logger_substitute.rb

@@ -1,97 +0,0 @@
-class ExtendedLogger
-  module LoggerSubstitute
-    attr_writer :clock
-    attr_reader :datetime_format
-    attr_writer :formatter
-    attr_reader :io
-    attr_accessor :progname
-
-    def initialize io
-      @io = io
-    end
-
-    def add severity, message=nil, progname=nil, &block
-      return if log_device.nil?
-
-      severity ||= self.class.const_get :UNKNOWN
-      return if severity < level
-
-      progname ||= self.progname
-
-      if message.nil?
-        if block
-          message = block.()
-        else
-          message = progname
-          progname = self.progname
-        end
-      end
-
-      severity_label = self.class.levels[severity] || 'ANY'.freeze
-
-      formatted_message = format severity_label, clock.now, progname, message
-
-      log_device.write formatted_message
-    end
-    alias_method :log, :add
-
-    def clock
-      @clock ||= Time
-    end
-
-    def close
-      log_device.close
-    end
-
-    def datetime_format= format
-      @datetime_format = format
-      default_formatter.datetime_format = format
-    end
-
-    def default_formatter
-      @default_formatter ||= Formatter.build
-    end
-
-    def format *arguments
-      formatter.(*arguments)
-    end
-
-    def formatter
-      @formatter ||= default_formatter
-    end
-
-    def level
-      @level ||= 0
-    end
-    alias_method :sev_threshold, :level
-
-    def level= severity_or_label
-      if severity_or_label.respond_to? :to_int
-        severity =  severity_or_label.to_int
-      end
-
-      unless severity
-        label = severity_or_label
-        level = label.to_s.upcase
-
-        severity = self.class.levels.index level
-      end
-
-      unless severity
-        raise ArgumentError, "Not a severity: #{severity_or_label.inspect}"
-      end
-
-      @level = severity
-    end
-    alias_method :sev_threshold=, :level=
-
-    def log_device
-      return unless io
-      @log_device ||= ::Logger::LogDevice.new io
-    end
-
-    def unknown progname=nil, &block
-      add nil, nil, progname, &block
-    end
-  end
-end

data/lib/extended_logger/per_class_logging.rb

@@ -1,40 +0,0 @@
-class ExtendedLogger
-  module PerClassLogging
-    attr_writer :logger
-
-    def cache
-      @cache ||= Hash.new do |hash, mod|
-        logger = self.logger.dup
-
-        logger.progname = mod
-        logger.level -= verbosity
-
-        hash[mod] = logger
-      end
-    end
-
-    def configure logger
-      self.logger = logger
-
-      cache.clear
-    end
-
-    def get mod
-      cache[mod]
-    end
-
-    def logger
-      @logger ||= Logger.new $stderr
-    end
-
-    def verbosity
-      @verbosity ||= 0
-    end
-
-    def verbosity= value
-      @verbosity = value
-
-      cache.clear
-    end
-  end
-end