cogger 0.24.1 → 0.26.0

data/lib/cogger/formatters/abstract.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    # An abstract class with common/shared functionality.
+    class Abstract
+      NEW_LINE = "\n"
+
+      SANITIZERS = {
+        escape: Sanitizers::Escape.new,
+        filter: Sanitizers::Filter,
+        format_time: Sanitizers::FormatTime
+      }.freeze
+
+      def initialize sanitizers: SANITIZERS
+        @sanitizers = sanitizers
+      end
+
+      def call(*)
+        fail NoMethodError,
+             "`#{self.class}##{__method__} #{method(__method__).parameters}` must be implemented."
+      end
+
+      protected
+
+      def sanitize entry, message
+        entry.public_send(message).tap do |attributes|
+          filter attributes
+          attributes.transform_values! { |value| format_time value, format: entry.datetime_format }
+        end
+      end
+
+      def escape(...) = sanitizers.fetch(__method__).call(...)
+
+      def filter(...) = sanitizers.fetch(__method__).call(...)
+
+      def format_time(...) = sanitizers.fetch(__method__).call(...)
+
+      private
+
+      attr_reader :sanitizers
+    end
+  end
+end

data/lib/cogger/formatters/color.rb

@@ -3,22 +3,27 @@
 module Cogger
   module Formatters
     # Formats by color.
-    class Color
+    class Color < Abstract
       TEMPLATE = "<dynamic>[%<id>s]</dynamic> %<message:dynamic>s"
 
-      def initialize template = TEMPLATE, processor: Processors::Color.new
+      def initialize template = TEMPLATE, parser: Parsers::Combined.new
+        super()
         @template = template
-        @processor = processor
+        @parser = parser
       end
 
       def call(*input)
-        updated_template, attributes = processor.call(template, *input)
-        "#{format(updated_template, **attributes).tap(&:strip!)}\n"
+        *, entry = input
+        attributes = sanitize entry, :tagged
+
+        format(parse(attributes[:level]), attributes).tap(&:strip!) << NEW_LINE
       end
 
       private
 
-      attr_reader :template, :processor
+      attr_reader :template, :parser
+
+      def parse(level) = parser.call template, level
     end
   end
 end

data/lib/cogger/formatters/crash.rb

@@ -3,7 +3,7 @@
 module Cogger
   module Formatters
     # Formats fatal crashes.
-    class Crash
+    class Crash < Abstract
       TEMPLATE = <<~CONTENT
         <dynamic>[%<id>s] [%<level>s] [%<at>s] Crash!
           %<message>s
@@ -11,20 +11,25 @@ module Cogger
         %<backtrace>s</dynamic>
       CONTENT
 
-      def initialize template = TEMPLATE, processor: Processors::Color.new
+      def initialize template = TEMPLATE, parser: Parsers::Combined.new
+        super()
         @template = template
-        @processor = processor
+        @parser = parser
       end
 
       def call(*input)
-        updated_template, attributes = processor.call(template, *input)
+        *, entry = input
+        attributes = sanitize entry, :tagged
         attributes[:backtrace] = %(  #{attributes[:backtrace].join "\n  "})
-        "#{format(updated_template, **attributes)}\n"
+
+        format(parse(attributes[:level]), attributes) << NEW_LINE
       end
 
       private
 
-      attr_reader :template, :processor
+      attr_reader :template, :parser
+
+      def parse(level) = parser.call template, level
     end
   end
 end

data/lib/cogger/formatters/json.rb

@@ -6,33 +6,25 @@ require "json"
 module Cogger
   module Formatters
     # Formats as JSON output.
-    class JSON
+    class JSON < Abstract
       TEMPLATE = nil
 
-      def initialize template = TEMPLATE,
-                     parser: Parsers::KeyExtractor.new,
-                     sanitizer: Kit::Sanitizer
-        @positions = template ? parser.call(template) : Core::EMPTY_ARRAY
-        @sanitizer = sanitizer
+      def initialize template = TEMPLATE, parser: Parsers::Position.new
+        super()
+        @template = template
+        @parser = parser
       end
 
       def call(*input)
-        attributes = sanitizer.call(*input).tagged_attributes.tap(&:compact!)
-        format_date_time attributes
+        *, entry = input
+        attributes = sanitize(entry, :tagged_attributes).tap(&:compact!)
 
-        return "#{attributes.to_json}\n" if positions.empty?
-
-        "#{attributes.slice(*positions).merge!(attributes.except(*positions)).to_json}\n"
+        parser.call(template, attributes).to_json << NEW_LINE
       end
 
       private
 
-      attr_reader :positions, :sanitizer
-
-      # :reek:UtilityFunction
-      def format_date_time attributes
-        attributes[:at] = attributes[:at].utc.strftime "%Y-%m-%dT%H:%M:%S.%L%:z"
-      end
+      attr_reader :template, :parser
     end
   end
 end

data/lib/cogger/formatters/parsers/abstract.rb

@@ -3,11 +3,13 @@
 module Cogger
   module Formatters
     module Parsers
-      # An abstrct class with default functionality.
+      # An abstract class with common functionality.
       class Abstract
-        def initialize registry: Cogger, colorizer: Kit::Colorizer, expressor: Regexp
+        TRANSFORMERS = {color: Transformers::Color.new, emoji: Transformers::Emoji.new}.freeze
+
+        def initialize registry: Cogger, transformers: TRANSFORMERS, expressor: Regexp
           @registry = registry
-          @colorizer = colorizer
+          @transformers = transformers
           @expressor = expressor
         end
 
@@ -18,7 +20,11 @@ module Cogger
 
         protected
 
-        attr_reader :registry, :colorizer, :expressor
+        attr_reader :registry, :transformers, :expressor
+
+        def transform_color(...) = transformers.fetch(:color).call(...)
+
+        def transform_emoji(...) = transformers.fetch(:emoji).call(...)
       end
     end
   end

data/lib/cogger/formatters/parsers/combined.rb

@@ -5,14 +5,14 @@ module Cogger
     module Parsers
       # Parses template literals, emojis, and keys for specific and dynamic colors.
       class Combined
-        STEPS = [Element.new, Emoji.new, Specific.new].freeze
+        STEPS = [Element.new, Emoji.new, Key.new].freeze # Order matters.
 
         def initialize steps: STEPS
           @steps = steps
         end
 
-        def call(template, **attributes)
-          steps.reduce(template.dup) { |modification, step| step.call modification, **attributes }
+        def call template, level
+          steps.reduce(template.dup) { |modification, step| step.call modification, level }
         end
 
         private

data/lib/cogger/formatters/parsers/element.rb

@@ -6,13 +6,13 @@ module Cogger
       # Parses template elements for specific and dynamic colors.
       class Element < Abstract
         PATTERN = %r(
-          <                # Tag open start.
-          (?<name>\w+)     # Tag open name.
-          >                # Tag open end.
-          (?<content>.+?)  # Content.
-          </               # Tag close start.
-          \w+              # Tag close.
-          >                # Tag close end.
+          <                  # Tag open start.
+          (?<directive>\w+)  # Tag open name.
+          >                  # Tag open end.
+          (?<content>.+?)    # Content.
+          </                 # Tag close start.
+          \w+                # Tag close.
+          >                  # Tag close end.
         )mx
 
         def initialize pattern: PATTERN
@@ -20,19 +20,21 @@ module Cogger
           @pattern = pattern
         end
 
-        def call(template, **)
-          template.gsub! pattern do
-            captures = expressor.last_match.named_captures
-            color = colorizer.call(captures["name"], **)
-            registry.color[captures["content"], color]
-          end
-
+        def call template, level
+          mutate template, level
           template
         end
 
         private
 
         attr_reader :pattern
+
+        def mutate template, level
+          template.gsub! pattern do
+            captures = expressor.last_match.named_captures
+            transform_color captures["content"], captures["directive"], level
+          end
+        end
       end
     end
   end

data/lib/cogger/formatters/parsers/emoji.rb

@@ -6,11 +6,11 @@ module Cogger
       # Parses template emojis for specific and dynamic colors.
       class Emoji < Abstract
         PATTERN = /
-          %<             # Start.
-          emoji          # Name.
-          :              # Delimiter.
-          (?<color>\w+)  # Color.
-          >s             # End.
+          %<                 # Start.
+          (?<key>emoji)      # Key.
+          :                  # Delimiter.
+          (?<directive>\w+)  # Directive.
+          >s                 # End.
         /x
 
         def initialize pattern: PATTERN
@@ -18,20 +18,21 @@ module Cogger
           @pattern = pattern
         end
 
-        def call(template, **)
-          template.gsub! pattern do
-            captures = expressor.last_match.named_captures
-            color = colorizer.call(captures["color"], **)
-
-            registry.get_emoji color
-          end
-
+        def call template, level
+          mutate template, level
           template
         end
 
         private
 
         attr_reader :pattern
+
+        def mutate template, level
+          template.gsub! pattern do
+            captures = expressor.last_match.named_captures
+            transform_emoji captures["key"], captures["directive"], level
+          end
+        end
       end
     end
   end

data/lib/cogger/formatters/parsers/{specific.rb → key.rb}

@@ -5,18 +5,17 @@ require "core"
 module Cogger
   module Formatters
     module Parsers
-      # Parses template for specific and dynamic string format specifiers.
-      class Specific < Abstract
+      # Parses template for specific and dynamic keys (i.e. string format specifiers).
+      class Key < Abstract
         PATTERN = /
           %                                   # Start.
           (?<flag>[\s#+-0*])?                 # Optional flag.
+          \.?                                 # Optional precision.
           (?<width>\d+)?                      # Optional width.
-          \.?                                 # Optional precision delimiter.
-          (?<precision>\d+)?                  # Optional precision value.
           <                                   # Reference start.
-          (?<name>\w+)                        # Name.
+          (?<key>\w+)                         # Key.
           :                                   # Delimiter.
-          (?<color>\w+)                       # Color.
+          (?<directive>\w+)                   # Directive.
           >                                   # Reference end.
           (?<specifier>[ABEGXabcdefgiopsux])  # Specifier.
         /x
@@ -26,23 +25,24 @@ module Cogger
           @pattern = pattern
         end
 
-        # :reek:TooManyStatements
-        def call(template, **)
-          template.gsub! pattern do |match|
-            captures = expressor.last_match.named_captures
-            original_color = captures["color"]
-            color = colorizer.call(original_color, **)
-
-            match.sub! ":#{original_color}", Core::EMPTY_STRING
-            registry.color[match, color]
-          end
-
+        def call template, level
+          mutate template, level
           template
         end
 
         private
 
         attr_reader :pattern
+
+        def mutate template, level
+          template.gsub! pattern do |match|
+            captures = expressor.last_match.named_captures
+            directive = captures["directive"]
+            match.sub! ":#{directive}", Core::EMPTY_STRING
+
+            transform_color match, directive, level
+          end
+        end
       end
     end
   end

data/lib/cogger/formatters/parsers/{key_extractor.rb → position.rb}

@@ -3,14 +3,14 @@
 module Cogger
   module Formatters
     module Parsers
-      # Parses template and extracts keys.
-      class KeyExtractor
+      # Parses template and reorders attributes based on template key positions.
+      class Position
         PATTERN = /
           %             # Start.
           ?             # Flag, width, or precision.
           <             # Reference start.
           (?<name>\w+)  # Name.
-          (?::[\w]+)?   # Optional delimiter and or color.
+          (?::[\w]+)?   # Optional delimiter and directive.
           >             # Reference end.
           ?             # Specifier.
         /x
@@ -19,11 +19,20 @@ module Cogger
           @pattern = pattern
         end
 
-        def call(template) = template.scan(pattern).map { |match| match.first.to_sym }
+        # :reek:FeatureEnvy
+        def call template, attributes
+          return attributes if !template || template.empty?
+          return attributes unless template.match? pattern
+
+          keys = scan template
+          attributes.slice(*keys).merge!(attributes.except(*keys))
+        end
 
         private
 
         attr_reader :pattern
+
+        def scan(template) = template.scan(pattern).map { |match| match.first.to_sym }
       end
     end
   end

data/lib/cogger/formatters/property.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "core"
+
+module Cogger
+  module Formatters
+    # Formats as key=value output.
+    class Property < Abstract
+      TEMPLATE = nil
+
+      def initialize template = TEMPLATE, parser: Parsers::Position.new
+        super()
+        @template = template
+        @parser = parser
+      end
+
+      def call(*input)
+        *, entry = input
+        attributes = sanitize(entry, :tagged_attributes).tap(&:compact!)
+
+        concat(attributes).chop! << NEW_LINE
+      end
+
+      private
+
+      attr_reader :template, :parser
+
+      def concat attributes
+        parser.call(template, attributes).each.with_object(+"") do |(key, value), line|
+          line << key.to_s << "=" << escape(value) << " "
+        end
+      end
+    end
+  end
+end

data/lib/cogger/formatters/sanitizers/escape.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Sanitizers
+      # Sanitizes value as fully quoted string for emojis, spaces, and control characters.
+      class Escape
+        PATTERN = /
+          \A              # Search string start.
+          .*              # Match zero or more characters.
+          (               # Conditional start.
+          (?!\p{Number})  # Look ahead and ignore unicode numbers.
+          \p{Emoji}       # Match unicode emoji only.
+          |               # Or.
+          [[:space:]]     # Match spaces, tabs, and new lines.
+          |               # Or.
+          [[:cntrl:]]     # Match control characters.
+          )               # Conditional end.
+          .*              # Match zero or more characters.
+          \z              # Search string end.
+        /xu
+
+        def initialize pattern: PATTERN
+          @pattern = pattern
+        end
+
+        def call value
+          return dump value unless value.is_a? Array
+
+          value.reduce(+"") { |text, item| text << dump(item) << ", " }
+               .then { |text| %([#{text.delete_suffix ", "}]).dump }
+        end
+
+        private
+
+        attr_reader :pattern
+
+        def dump(value) = value.to_s.gsub(pattern, &:dump)
+      end
+    end
+  end
+end

data/lib/cogger/formatters/sanitizers/filter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Sanitizers
+      # Sanitizes/removes sensitive values.
+      Filter = lambda do |attributes, filters: Cogger.filters|
+        filters.each { |key| attributes[key] = "[FILTERED]" if attributes.key? key }
+        attributes
+      end
+    end
+  end
+end

data/lib/cogger/formatters/sanitizers/format_time.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Cogger
+  module Formatters
+    module Sanitizers
+      # Sanitizes/formats date/time value.
+      FormatTime = lambda do |value, format: Cogger::DATETIME_FORMAT|
+        return value unless value.is_a?(::Time) || value.is_a?(Date) || value.is_a?(::DateTime)
+
+        value.strftime format
+      end
+    end
+  end
+end

data/lib/cogger/formatters/simple.rb

@@ -2,20 +2,25 @@
 
 module Cogger
   module Formatters
-    # Formats simple templates that require no additional processing.
-    class Simple
+    # Formats simple templates that require minimal processing.
+    class Simple < Abstract
       TEMPLATE = "[%<id>s] %<message>s"
 
-      def initialize template = TEMPLATE, sanitizer: Kit::Sanitizer
+      def initialize template = TEMPLATE
+        super()
         @template = template
-        @sanitizer = sanitizer
       end
 
-      def call(*input) = "#{format(template, sanitizer.call(*input).tagged).tap(&:strip!)}\n"
+      def call(*input)
+        *, entry = input
+        attributes = sanitize entry, :tagged
+
+        format(template, attributes).tap(&:strip!) << NEW_LINE
+      end
 
       private
 
-      attr_reader :template, :sanitizer
+      attr_reader :template, :processor
     end
   end
 end

data/lib/cogger/formatters/transformers/color.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Transformers
+      # Transforms target into colorized string.
+      class Color
+        def initialize emoji: Emoji::KEY, key_transformer: Key, registry: Cogger
+          @emoji = emoji
+          @key_transformer = key_transformer
+          @registry = registry
+        end
+
+        def call target, directive, level
+          return target if !target.is_a?(String) || target == emoji
+
+          key = key_transformer.call directive, level
+
+          return client.encode target, key if aliases.key?(key) || defaults.key?(key)
+
+          target
+        end
+
+        private
+
+        attr_reader :emoji, :key_transformer, :registry
+
+        def aliases = registry.aliases
+
+        def defaults = client.defaults
+
+        def client = registry.color
+      end
+    end
+  end
+end

data/lib/cogger/formatters/transformers/emoji.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Transformers
+      # Transforms target into emoji.
+      class Emoji
+        KEY = "emoji"
+
+        def initialize key = KEY, key_transformer: Key, registry: Cogger
+          @key = key
+          @key_transformer = key_transformer
+          @registry = registry
+        end
+
+        def call target, directive, level
+          return target unless target == key
+
+          key = key_transformer.call directive, level
+
+          registry.aliases.key?(key) ? registry.get_emoji(key) : target
+        end
+
+        private
+
+        attr_reader :key, :key_transformer, :registry
+      end
+    end
+  end
+end

data/lib/cogger/formatters/transformers/key.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Transformers
+      # Transforms directive, based on log level, into a key for color or emoji lookup.
+      Key = -> directive, level { (directive == "dynamic" ? level.downcase : directive).to_sym }
+    end
+  end
+end

data/lib/cogger/hub.rb

@@ -100,12 +100,14 @@ module Cogger
       crash message, error
     end
 
+    # rubocop:todo Metrics/MethodLength
     def dispatch(level, message, **payload, &)
       entry = configuration.entry.for(
         message,
         id: configuration.id,
         level:,
         tags: configuration.entag(payload.delete(:tags)),
+        datetime_format: configuration.datetime_format,
         **payload,
         &
       )
@@ -113,6 +115,7 @@ module Cogger
       mutex.synchronize { streams.each { |logger| logger.public_send level, entry } }
       true
     end
+    # rubocop:enable Metrics/MethodLength
 
     def crash message, error
       configuration.with(id: :cogger, io: $stdout, formatter: Formatters::Crash.new)

data/lib/cogger/program.rb

@@ -2,7 +2,7 @@
 
 require "pathname"
 
-# Provides a function for computing the default program name based on current file.
+# Computes default program name based on current file name.
 module Cogger
   Program = lambda do |name = $PROGRAM_NAME|
     Pathname(name).then { |path| path.basename(path.extname).to_s }