extended_logger 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69fbd42275b49a88b59b5c6c9304b1c85802ec13
-  data.tar.gz: df224b6d6ab28e632911b59f567afc139c29b664
+  metadata.gz: 12acc57301fb31c71adadd859ed1e9227adf4e38
+  data.tar.gz: 15e746abb842188e8c1f2d4786f9c7161d35dc60
 SHA512:
-  metadata.gz: 56c924b08014891c69e89515d24049c90f942767cdafdd12d5507359e164f382c69e2980e045171a68f6cb491ffeb97d8283865cf8c3d5b01c83f6f240c1e3a0
-  data.tar.gz: d204424f8e5a9b97afcd95b48d2e463cfb462a5f36a6665d5aab55b5f5e6a7ffa99059d45182961ab0685801479437021a4ff803105514845fe9367110a1754b
+  metadata.gz: 19703c7afe912c2c68227efc333641b5d520f98688f73ca23c05261f6bb5984d93e2e6796af3d4593006db05bcd631c9dc66e07bc4d7864358b0aa4c8f4813ec
+  data.tar.gz: c32d52b617a488dd072899e87e2f1d09a268e4a3a71d4878bbd5186d20e060b9d97e8ea2f26fbc696451765414aa46d829ba40966d234843454920124d74ceb2

data/lib/extended_logger.rb

@@ -1,6 +1,9 @@
 require 'logger'
 
 require 'extended_logger/extended_logger'
-require 'extended_logger/factory'
+
+require 'extended_logger/colors'
+require 'extended_logger/colors/pack'
+require 'extended_logger/colors/unpack'
+require 'extended_logger/define'
 require 'extended_logger/formatter'
-require 'extended_logger/null_logger'

data/lib/extended_logger/colors.rb

@@ -0,0 +1,50 @@
+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/colors/pack.rb

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

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

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

data/lib/extended_logger/extended_logger.rb

@@ -1,93 +1,38 @@
 class ExtendedLogger < Logger
-  class << self
-    attr_accessor :default_log_level
+  attr_accessor :always_evaluate
 
-    def configure receiver, attribute_name=nil, **overrides
-      attribute_name ||= 'logger'.freeze
-      setter = "#{attribute_name}=".freeze
+  def initialize *;
+    super
 
-      logger = get receiver, **overrides
-
-      receiver.public_send setter, logger
-    end
-
-    def get receiver, **overrides
-      receiver_name =
-        if receiver.is_a? Module
-          receiver.name
-        else
-          receiver.class.name
-        end
-
-      logger = Factory.(**overrides)
-      logger.progname = "(#{receiver_name})"
-      logger
-    end
-
-    def instance
-      @instance ||= Factory.()
-    end
-
-    def levels
-      @levels ||= {
-        -7 => 'OBSOLETE'.freeze,
-        -6 => 'OPT_DATA'.freeze,
-        -5 => 'OPT_TRACE'.freeze,
-        -4 => 'OPT_DEBUG'.freeze,
-        -3 => 'DATA'.freeze,
-        -2 => 'TRACE'.freeze,
-        -1 => 'DEBUG'.freeze,
-        0 => 'INFO'.freeze,
-        1 => 'PASS'.freeze,
-        2 => 'FAIL'.freeze,
-        3 => 'FOCUS'.freeze,
-        4 => 'WARN'.freeze,
-        5 => 'ERROR'.freeze,
-        6 => 'FATAL'.freeze,
-      }
-    end
-
-    def level? level
-      levels.key? level
-    end
+    formatter_cls = self.class.const_get :Formatter
+    @formatter = formatter_cls.new @default_formatter
   end
 
-  def datetime_format
-    formatter.datetime_format
+  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 datetime_format= format
-    formatter.datetime_format = format
+  def add severity, *, &block
+    block.call if block_given? and always_evaluate and severity < @level
+    super
   end
 
-  def format_severity severity
-    unless self.class.level? severity
-      Kernel.warn "(extended-logger) Unknown log severity level #{severity.inspect}"
-    end
-
-    self.class.levels.fetch severity, 'ANY'.freeze
-  end
+  def apply_extensions always_evaluate: nil, color_swatch: nil
+    always_evaluate ||= false
 
-  def formatter= formatter
-    if self.formatter.is_a? Formatter
-      self.formatter.logger_formatter = formatter
-    else
-      super
-    end
-  end
+    self.always_evaluate = always_evaluate
 
-  def io
-    return unless @logdev
-    @logdev.dev
+    formatter.color_swatch = Colors.unpack color_swatch if color_swatch
   end
 
-  def unknown *arguments, &block
-    add 7, *arguments, &block
+  def formatter= internal_formatter
+    formatter.internal_formatter = internal_formatter
   end
 
-  levels.each do |level, name|
-    define_method name.downcase do |*arguments, &block|
-      add level, *arguments, &block
-    end
+  def self.define &block
+    Define.(block)
   end
 end

data/lib/extended_logger/formatter.rb

@@ -1,97 +1,39 @@
 class ExtendedLogger
   class Formatter
-    attr_writer :logger_formatter
-    attr_writer :palette
+    attr_writer :color_swatch
+    attr_accessor :internal_formatter
 
-    def call severity, *arguments
-      log_entry = delegate severity, *arguments
-      color log_entry, severity
+    def initialize internal_formatter
+      @internal_formatter = internal_formatter
     end
 
-    def color log_entry, severity
-      colorizer = palette[severity]
-
-      if colorizer
-        log_entry = "#{colorizer}#{log_entry}\e[0m"
-      end
-
-      log_entry
-    end
-
-    def datetime_format
-      logger_formatter.datetime_format
-    end
-
-    def datetime_format= format
-      logger_formatter.datetime_format = format
-    end
-
-    def delegate *arguments, message
-      message = format_message message, arguments
-      logger_formatter.(*arguments, message)
-    end
-
-    def format_message message, arguments
+    def call severity, *arguments, message
       output = ''
 
-      message.each_line "\n".freeze do |line|
-        if line == "\n".freeze
-          line = "\\n"
-        else
-          line.gsub! "\r".freeze, "\\r".freeze
-        end
+      message = '(empty log message)' if message.empty?
 
-        if output.empty?
-          output.concat line
-        else
-          formatted_line = logger_formatter.(*arguments, line.chomp("\n".freeze))
-          output.concat formatted_line
-        end
-      end
+      message.gsub! "\r".freeze, "\\r".freeze
 
-      output.chomp "\n".freeze
-    end
+      message.each_line do |line|
+        line = $/.inspect[1...-1] if line == $/
+        line.chomp! if line.end_with? $/
 
-    def logger_formatter
-      @logger_formatter ||= Logger::Formatter.new
-    end
+        formatted_line = internal_formatter.(severity, *arguments, line)
+        output.concat formatted_line
+      end
 
-    def palette
-      @palette ||= {}
-    end
+      color = color_swatch[severity] || color_swatch['ANY'.freeze]
+      Colors.apply output, **color if color
 
-    def self.ansi_colors
-      @ansi_colors ||= %i(black red green yellow blue magenta cyan white)
+      output
     end
 
-    def self.col fg, brightness, bg=nil
-      brightness = { :bright => 1, :normal => 0 }.fetch brightness
-      escape = "\e[#{brightness};3#{ansi_colors.index fg}m"
-
-      if bg
-        escape << "\e[4#{ansi_colors.index bg}m"
-      end
-
-      escape
+    def color_swatch
+      @color_swatch ||= {}
     end
 
-    def self.default_palette
-      @default_palette ||= {
-        'OBSOLETE' => col(:black, :normal),
-        'DATA' => col(:green, :normal),
-        'TRACE' => col(:cyan, :normal),
-        'DEBUG' => col(:blue, :normal),
-        'OPT_DATA' => col(:green, :normal, :white),
-        'OPT_TRACE' => col(:cyan, :normal, :white),
-        'OPT_DEBUG' => col(:blue, :normal, :white),
-        'PASS' => col(:white, :bright, :green),
-        'FAIL' => col(:white, :bright, :red),
-        'FOCUS' => col(:white, :bright, :blue),
-        'WARN' => col(:yellow, :normal),
-        'ERROR' => col(:red, :normal),
-        'FATAL' => col(:black, :bright, :red),
-        'ANY' => col(:white, :bright, :magenta),
-      }
+    def datetime_format= value
+      internal_formatter.datetime_format = value
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: extended_logger
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Nathan Ladd
@@ -21,10 +21,12 @@ 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/extended_logger.rb
-- lib/extended_logger/factory.rb
 - lib/extended_logger/formatter.rb
-- lib/extended_logger/null_logger.rb
 homepage: https://github.com/ntl/extended-logger
 licenses:
 - MIT

data/lib/extended_logger/factory.rb

@@ -1,61 +0,0 @@
-class ExtendedLogger
-  class Factory
-    attr_reader :env
-    attr_writer :device
-    attr_writer :level
-
-    def initialize env
-      @env = env
-    end
-
-    def self.build env=nil, device: nil, level: nil
-      env ||= ENV
-      level ||= ExtendedLogger.default_log_level
-
-      instance = new env
-      instance.device = device if device
-      instance.level = level if level
-      instance
-    end
-
-    def self.call *arguments
-      instance = build *arguments
-      instance.()
-    end
-
-    def call
-      logger = ExtendedLogger.new device
-
-      formatter = Formatter.new
-      formatter.palette = Formatter.default_palette if colors? logger.io
-      logger.formatter = formatter
-
-      level = self.level
-      logger.level = level if level
-
-      logger
-    end
-
-    def colors? io
-      if io.tty?
-        ENV['LOG_COLOR'] != 'off'
-      else
-        ENV['LOG_COLOR'] == 'on'
-      end
-    end
-
-    def device
-      @device || env['LOG_DEVICE'] || $stderr
-    end
-
-    def level
-      level = @level || env['LOG_LEVEL']
-
-      return unless level
-      return level if level.is_a? Integer
-
-      level , _ = ExtendedLogger.levels.rassoc level.upcase
-      level
-    end
-  end
-end

data/lib/extended_logger/null_logger.rb

@@ -1,3 +0,0 @@
-class ExtendedLogger
-  NullLogger = self.new '/dev/null'
-end