extended_logger 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12acc57301fb31c71adadd859ed1e9227adf4e38
-  data.tar.gz: 15e746abb842188e8c1f2d4786f9c7161d35dc60
+  metadata.gz: 47bdad0e0a33ecdf506b71aa4bb4784085583b19
+  data.tar.gz: 7e3ae841f32d58d983af5d7062e4e18145ddba1a
 SHA512:
-  metadata.gz: 19703c7afe912c2c68227efc333641b5d520f98688f73ca23c05261f6bb5984d93e2e6796af3d4593006db05bcd631c9dc66e07bc4d7864358b0aa4c8f4813ec
-  data.tar.gz: c32d52b617a488dd072899e87e2f1d09a268e4a3a71d4878bbd5186d20e060b9d97e8ea2f26fbc696451765414aa46d829ba40966d234843454920124d74ceb2
+  metadata.gz: 7f993016f5115afb6b3cf8a63a37dfc09209bdca075a1eff70666b0de2704502569325f811d1e7a61e9991091768615b11cc10b8c82ca81ff75e549ba21b3226
+  data.tar.gz: 998ee7a2958d74795175ff3e69e138651b6eeeb40df13d506f81b28e6c53f367e611c36f4737deba6d3918ea65ef78fe29809770d46460d7f5d45cbd6b312cb4

data/lib/extended_logger/color_scheme.rb

@@ -0,0 +1,124 @@
+class ExtendedLogger
+  class ColorScheme
+    attr_reader :map
+
+    def initialize map
+      @map = map
+    end
+
+    def self.build symbol_map
+      code_map = {}
+
+      symbol_map.each do |label, (fg_sym, bg_sym)|
+        fg = Colors.index fg_sym
+        bg = Colors.index bg_sym
+
+        code_map[label] = [fg, bg]
+      end
+
+      new code_map
+    end
+
+    def color_code code
+      if code
+        code.to_s 16
+      else
+        '?'.freeze
+      end
+    end
+
+    def colorize severity, text
+      fg, bg = map[severity]
+
+      if bg
+        if bg > 8
+          text.insert 0, "\e[4#{bg - 8}m"
+        else
+          text.insert 0, "\e[4#{bg}m"
+        end
+      end
+
+      if fg
+        if fg > 8
+          text.insert 0, "\e[1;3#{fg - 8}m"
+        else
+          text.insert 0, "\e[0;3#{fg}m"
+        end
+      end
+
+      if fg or bg
+        text << "\e[0m"
+      end
+
+      text
+    end
+
+    def dump
+      output = ''
+      output.force_encoding 'US-ASCII'
+
+      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}"
+      end
+
+      output
+    end
+
+    def self.decode code
+      return if code == '?'.freeze
+      code.to_i 16
+    end
+
+    def self.load data
+      map = {}
+
+      values = data.split ','.freeze
+
+      values.each do |assignment|
+        match_data = AssignmentPattern.match assignment
+
+        label = match_data[:label]
+        fg = decode match_data[:fg_code]
+        bg = decode match_data[:bg_code]
+
+        map[label] = [fg, bg]
+      end
+
+      new map
+    end
+
+    Colors = %i(
+      black
+      red
+      green
+      brown
+      blue
+      magenta
+      cyan
+      gray
+
+      dark_gray
+      bright_red
+      bright_green
+      yellow
+      bright_blue
+      bright_magenta
+      bright_cyan
+      white
+    )
+
+    AssignmentPattern = %r{\A
+      (?<label>[_A-Z]+)
+      =
+      (?<fg_code>[?[:xdigit:]])+
+      ;
+      (?<bg_code>[?[:xdigit:]]+)\z
+    }nx
+
+    Null = self.new Hash.new
+  end
+end

data/lib/extended_logger/configure_levels.rb

@@ -0,0 +1,35 @@
+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/controls.rb

@@ -0,0 +1,49 @@
+class ExtendedLogger
+  module Controls
+    module ColorSchemes
+      def self.normal_verbose
+        color_scheme = ExtendedLogger::ColorScheme.build(
+          'NORMAL' => [:gray, :none],
+          'VERBOSE' => [:none, :gray],
+        )
+      end
+    end
+
+    module Loggers
+      class NormalVerbose < ExtendedLogger
+        self.levels = %w(VERBOSE NORMAL)
+      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"
+      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
+      end
+    end
+  end
+end

data/lib/extended_logger/extended_logger.rb

@@ -1,38 +1,46 @@
-class ExtendedLogger < Logger
-  attr_accessor :always_evaluate
+class ExtendedLogger
+  include LoggerSubstitute
+  extend PerClassLogging
 
-  def initialize *;
-    super
+  attr_accessor :always_interpolate
+  attr_writer :color_scheme
 
-    formatter_cls = self.class.const_get :Formatter
-    @formatter = formatter_cls.new @default_formatter
-  end
+  def self.build io, always_interpolate: nil, color_scheme: nil
+    instance = new io
+
+    instance.always_interpolate = true if always_interpolate
+
+    if color_scheme
+      color_scheme = ColorScheme.load color_scheme if color_scheme.is_a? String
+      instance.color_scheme = color_scheme
+    end
 
-  def self.build *arguments, initial_level: nil, **extensions
-    instance = new *arguments
-    instance.level = initial_level if initial_level
-    instance.apply_extensions **extensions
     instance
   end
 
   def add severity, *, &block
-    block.call if block_given? and always_evaluate and severity < @level
+    if always_interpolate and severity < level
+      block.() if block
+    end
+
     super
   end
 
-  def apply_extensions always_evaluate: nil, color_swatch: nil
-    always_evaluate ||= false
-
-    self.always_evaluate = always_evaluate
+  def color_scheme
+    @color_scheme ||= ColorScheme::Null
+  end
 
-    formatter.color_swatch = Colors.unpack color_swatch if color_swatch
+  def format severity, *arguments
+    formatted_message = super
+    color_scheme.colorize severity, formatted_message
   end
 
-  def formatter= internal_formatter
-    formatter.internal_formatter = internal_formatter
+  def self.levels= levels
+    ConfigureLevels.configure_levels self, levels
   end
 
-  def self.define &block
-    Define.(block)
+  # ExtendedLogger::Logger can be used in place of ::Logger
+  class Logger < ExtendedLogger
+    self.levels = %w(DEBUG INFO WARN ERROR FATAL)
   end
 end

data/lib/extended_logger/formatter.rb

@@ -1,39 +1,27 @@
 class ExtendedLogger
-  class Formatter
-    attr_writer :color_swatch
-    attr_accessor :internal_formatter
-
-    def initialize internal_formatter
-      @internal_formatter = internal_formatter
-    end
-
-    def call severity, *arguments, message
-      output = ''
-
-      message = '(empty log message)' if message.empty?
-
-      message.gsub! "\r".freeze, "\\r".freeze
-
-      message.each_line do |line|
-        line = $/.inspect[1...-1] if line == $/
-        line.chomp! if line.end_with? $/
-
-        formatted_line = internal_formatter.(severity, *arguments, line)
-        output.concat formatted_line
+  class Formatter < ::Logger::Formatter
+    BlankLine = /\A[[:blank:]]*\z/n
+    LineEnding = /[[:blank:]]*\r*[\r\n]/n
+    Separator = "\n".freeze
+
+    def call *arguments, message
+      if BlankLine.match message.to_s
+        super *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 = super *arguments, line
+          output << formatted_line
+          output
+        end
       end
-
-      color = color_swatch[severity] || color_swatch['ANY'.freeze]
-      Colors.apply output, **color if color
-
-      output
-    end
-
-    def color_swatch
-      @color_swatch ||= {}
-    end
-
-    def datetime_format= value
-      internal_formatter.datetime_format = value
     end
   end
 end

data/lib/extended_logger/logger_substitute.rb

@@ -0,0 +1,97 @@
+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.new
+    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

@@ -0,0 +1,40 @@
+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

data/lib/extended_logger.rb

@@ -1,9 +1,10 @@
 require 'logger'
+require 'time'
 
-require 'extended_logger/extended_logger'
-
-require 'extended_logger/colors'
-require 'extended_logger/colors/pack'
-require 'extended_logger/colors/unpack'
-require 'extended_logger/define'
+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'

metadata

@@ -1,32 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: extended_logger
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Nathan Ladd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-09 00:00:00.000000000 Z
+date: 2016-01-10 00:00:00.000000000 Z
 dependencies: []
-description: |
-  extended-logger provides a richer logger implementation than the built in ruby
-  logger, offering more log levels and colors. In addition, loggers can be
-  constructed for your classes and modules, which include the constant name in
-  output for easy filtering.
+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.
+
+'
 email: nathanladd+github@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/extended_logger.rb
-- lib/extended_logger/colors.rb
-- lib/extended_logger/colors/pack.rb
-- lib/extended_logger/colors/unpack.rb
-- lib/extended_logger/define.rb
+- lib/extended_logger/color_scheme.rb
+- lib/extended_logger/configure_levels.rb
+- lib/extended_logger/controls.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
 homepage: https://github.com/ntl/extended-logger
 licenses:
 - MIT
@@ -47,9 +49,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Provides an extended logger offering more features than the ruby logger
+summary: An alternative to the built-in Logger
 test_files: []
-has_rdoc: 

data/lib/extended_logger/colors/pack.rb

@@ -1,47 +0,0 @@
-class ExtendedLogger
-  module Colors
-    class Pack
-      attr_reader :mapping
-
-      def initialize mapping
-        @mapping = mapping
-      end
-
-      def self.call mapping=nil
-        mapping ||= {}
-
-        instance = new mapping
-        instance.()
-      end
-
-      def call
-        output = ''.encode 'US-ASCII'
-
-        mapping.sort.each do |level_name, hash|
-          fg, bg = hash.values_at(:fg, :bg).map do |color_name|
-            color_code color_name
-          end
-
-          output << ',' unless output.empty?
-          output << "#{level_name.upcase}=#{fg};#{bg}"
-        end
-
-        Unpack.(output)
-
-        output
-      end
-
-      def color_code color_name
-        return '?'.freeze if color_name == :none
-
-        number = Colors.index color_name
-
-        unless number
-          raise ArgumentError, "#{color_name.inspect} is not a color code"
-        end
-
-        number.to_s 16
-      end
-    end
-  end
-end

data/lib/extended_logger/colors/unpack.rb

@@ -1,55 +0,0 @@
-class ExtendedLogger
-  module Colors
-    class Unpack
-      attr_reader :data
-
-      Pattern = %r{\A
-        (?<level_name>[A-Z_]+)    # DEBUG
-        =                         #      =
-        (?<fg>[?[:xdigit:]])+     #       f
-        ;                         #        ;
-        (?<bg>[?[:xdigit:]])+     #         8
-      \Z}xn
-
-      def initialize data
-        @data = data
-      end
-
-      def self.call string
-        instance = new string
-        instance.()
-      end
-
-      def call
-        output = {}
-        mappings = data.split ','.freeze
-
-        mappings.each do |mapping|
-          match_data = Pattern.match mapping
-
-          unless match_data
-            raise ArgumentError, "Invalid swatch #{data.inspect}"
-          end
-
-          level_name = match_data[:level_name]
-
-          if match_data[:fg] == '?'.freeze
-            fg = :none
-          else
-            fg = Colors.fetch match_data[:fg].to_i(16)
-          end
-
-          if match_data[:bg] == '?'.freeze
-            bg = :none
-          else
-            bg = Colors.fetch match_data[:bg].to_i(16)
-          end
-
-          output[level_name] = { :fg => fg, :bg => bg }
-        end
-
-        output
-      end
-    end
-  end
-end

data/lib/extended_logger/colors.rb

@@ -1,50 +0,0 @@
-class ExtendedLogger
-  module Colors
-    extend self
-
-    def apply text, fg:, bg:;
-      fg = Colors.index fg
-      bg = Colors.index bg
-
-      if fg
-        if fg > 8 then fg = "1;3#{fg - 8}" else fg = "0;3#{fg}" end
-        text.insert 0, "\e[#{fg}m"
-      end
-
-      if bg
-        if bg > 8 then bg = "4#{bg - 8}" else bg = "4#{bg}" end
-        text.insert 0, "\e[#{bg}m"
-      end
-
-      text.insert -1, "\e[0m" if fg or bg
-    end
-
-    def pack mapping=nil
-      Pack.(mapping)
-    end
-
-    def unpack data
-      Unpack.(data)
-    end
-
-    Colors = %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

data/lib/extended_logger/define.rb

@@ -1,55 +0,0 @@
-class ExtendedLogger
-  class Define
-    attr_reader :block
-    attr_reader :cls
-
-    DefaultLogLevels = %i(debug debug? error error? fatal fatal? info info? warn warn?)
-
-    def initialize block, cls
-      @block = block
-      @cls = cls
-    end
-
-    def self.call block
-      cls = Class.new ExtendedLogger
-
-      instance = new block, cls
-      instance.()
-    end
-
-    def call
-      cls.send :undef_method, *DefaultLogLevels
-
-      instance_exec &block
-
-      null_logger = cls.new nil
-      cls.const_set :NullLogger, null_logger
-
-      cls
-    end
-
-    def default_formatter &block
-      formatter_cls = Class.new Formatter
-      formatter_cls.send :define_method, :call, &block
-      cls.const_set :Formatter, formatter_cls
-    end
-
-    def levels const_names
-      const_names.each_with_index do |const_name, level|
-        cls.const_set const_name, level
-
-        method_name = const_name.to_s.downcase
-
-        cls.send :define_method, method_name do |progname=nil, &block|
-          add level, nil, progname, &block
-        end
-
-        cls.send :define_method, "#{method_name}?" do
-          @level <= level
-        end
-      end
-
-      cls.const_set :UNKNOWN, const_names.size
-    end
-  end
-end