cogger 0.6.0 → 0.7.0

data/lib/cogger/formatters/color.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    # Formats by color.
+    class Color
+      TEMPLATE = "%<message:dynamic>s"
+
+      def initialize template = TEMPLATE, processor: Processors::Color.new
+        @template = template
+        @processor = processor
+      end
+
+      def call(*entry)
+        updated_template, attributes = processor.call(template, *entry)
+        "#{format(updated_template, **attributes)}\n"
+      end
+
+      private
+
+      attr_reader :template, :processor
+    end
+  end
+end

data/lib/cogger/formatters/crash.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    # Formats fatal crashes.
+    class Crash
+      TEMPLATE = <<~CONTENT
+        <dynamic>[%<id>s] [%<severity>s] [%<at>s] Crash!
+          %<message>s
+          %<error_message>s (%<error_class>s)
+        %<backtrace>s</dynamic>
+      CONTENT
+
+      def initialize template = TEMPLATE, processor: Processors::Color.new
+        @template = template
+        @processor = processor
+      end
+
+      def call(*entry)
+        updated_template, attributes = processor.call(template, *entry)
+        attributes[:backtrace] = %(  #{attributes[:backtrace].join "\n  "})
+        "#{format(updated_template, **attributes)}\n"
+      end
+
+      private
+
+      attr_reader :template, :processor
+    end
+  end
+end

data/lib/cogger/formatters/json.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Cogger
+  module Formatters
+    # Formats as JSON output.
+    class JSON
+      TEMPLATE = "%<id>s %<severity>s %<at>s %<message>s"
+
+      def initialize template = TEMPLATE,
+                     parser: Parsers::Individual.new,
+                     sanitizer: Kit::Sanitizer.new
+        @template = template
+        @parser = parser
+        @sanitizer = sanitizer
+      end
+
+      def call(*entry)
+        positions = parser.call(template).last.keys
+        attributes = sanitizer.call(*entry)
+        "#{attributes.slice(*positions).merge!(attributes.except(*positions)).to_json}\n"
+      end
+
+      private
+
+      attr_reader :template, :parser, :sanitizer
+    end
+  end
+end

data/lib/cogger/formatters/kit/colorizer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Kit
+      # Transform color based on dynamic (severity) or standard color preference.
+      Colorizer = lambda do |value, attributes|
+        value == "dynamic" ? attributes[:severity].downcase : value
+      end
+    end
+  end
+end

data/lib/cogger/formatters/kit/sanitizer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Kit
+      # Transforms a positional log entry into a hash entry for template parsing and formatting.
+      class Sanitizer
+        def initialize filters: Cogger.filters
+          @filters = filters
+        end
+
+        # :reek:FeatureEnvy
+        def call(*entry)
+          severity, at, id, message = entry
+
+          attributes = if message.is_a? Hash
+                         {id:, severity:, at:, **message.except(:id, :severity, :at)}
+                       else
+                         {id:, severity:, at:, message:}
+                       end
+
+          filter attributes
+        end
+
+        private
+
+        attr_reader :filters
+
+        # :reek:FeatureEnvy
+        def filter attributes
+          filters.each { |key| attributes[key] = "[FILTERED]" if attributes.key? key }
+          attributes
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Parsers
+      # Dynamically extracts the universal or individual template attributes for log entry parsing.
+      class Dynamic
+        # Order matters.
+        DELEGATES = [Universal.new, Individual.new].freeze
+
+        def initialize delegates: DELEGATES
+          @delegates = delegates
+        end
+
+        def call(template) = parse(template) || template
+
+        private
+
+        attr_reader :delegates
+
+        def parse template
+          delegates.find do |delegate|
+            result = delegate.call template
+            break result unless result == template
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Parsers
+      # Sanitizes and extracts individual directives from a template.
+      class Individual
+        # rubocop:todo Lint/MixedRegexpCaptureTypes
+        PATTERN = /
+                    %                                   # Strict reference syntax.
+                    (?<flag>[\s#+-0*])?                 # Optional flag.
+                    (?<width>\d+)?                      # Optional width.
+                    \.?                                 # Optional precision delimiter.
+                    (?<precision>\d+)?                  # Optional precision value.
+                    <                                   # Reference start.
+                    (                                   # Conditional start.
+                    (?<key>\w+)                         # Key.
+                    :                                   # Directive delimiter.
+                    (?<directive>\w+)                   # Value.
+                    |                                   # Conditional.
+                    (?<key>\w+)                         # Key.
+                    )                                   # Conditional end.
+                    >                                   # Reference end.
+                    (?<specifier>[ABEGXabcdefgiopsux])  # Specifier.
+                  /mx
+        # rubocop:enable Lint/MixedRegexpCaptureTypes
+
+        def initialize pattern: PATTERN
+          @pattern = pattern
+        end
+
+        def call template
+          return template unless template.match? pattern
+
+          attributes = {}
+          template = sanitize_and_extract template, attributes
+          [template, attributes]
+        end
+
+        private
+
+        attr_reader :pattern
+
+        # :reek:FeatureEnvy
+        # :reek:TooManyStatements
+        def sanitize_and_extract template, attributes
+          template.dup.gsub pattern do
+            captures = Regexp.last_match.named_captures
+            attributes[captures["key"].to_sym] = captures["directive"]
+
+            captures.reduce(+"%") do |body, (key, value)|
+              next body if key == "directive"
+
+              body.concat key == "key" ? "<#{value}>" : value.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Parsers
+      # Sanitizes and extracts the universal directive a template.
+      class Universal
+        # rubocop:todo Lint/MixedRegexpCaptureTypes
+        PATTERN = %r(
+                    (                  # Conditional start.
+                    \A                 # Search start.
+                    <                  # Tag start.
+                    (?<directive>\w+)  # Directive.
+                    >                  # Tag end.
+                    |                  # Conditional pipe.
+                    <                  # Tag start.
+                    /                  # Tag close.
+                    (?<directive>\w+)  # Directive.
+                    >                  # Tag end.
+                    \Z                 # Search end.
+                    )                  # Conditional end.
+                  )mx
+        # rubocop:enable Lint/MixedRegexpCaptureTypes
+
+        KEY = "directive"
+
+        def initialize pattern: PATTERN, key: KEY
+          @pattern = pattern
+          @key = key
+        end
+
+        def call template
+          return template unless template.match? pattern
+
+          [template.gsub(pattern, ""), template.match(pattern)[key]]
+        end
+
+        private
+
+        attr_reader :pattern, :key
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "tone"
+
+module Cogger
+  module Formatters
+    module Processors
+      # Processes emojis and colors.
+      class Color
+        def initialize parser: Parsers::Dynamic.new,
+                       kit: {sanitizer: Kit::Sanitizer.new, colorizer: Kit::Colorizer},
+                       registry: Cogger
+          @parser = parser
+          @kit = kit
+          @registry = registry
+        end
+
+        def call(template, *entry)
+          attributes = sanitizer.call(*entry)
+
+          case parser.call template
+            in [String => body, String => style] then universal body, style, **attributes
+            in [String => body, Hash => styles] then individual body, attributes, styles
+            else [template, {}]
+          end
+        end
+
+        private
+
+        attr_reader :parser, :kit, :registry
+
+        def universal body, style, **attributes
+          [registry.color[body, colorizer.call(style, attributes)], attributes]
+        end
+
+        def individual body, attributes, styles
+          attributes = attributes.each.with_object({}) do |(key, value), collection|
+            collection[key] = registry.color[value, colorizer.call(styles[key], attributes)]
+          end
+
+          emojify attributes, styles
+          [body, attributes]
+        end
+
+        def emojify attributes, styles
+          style = styles[:emoji]
+
+          return unless style
+
+          attributes[:emoji] = registry.get_emoji colorizer.call(style, attributes)
+        end
+
+        def sanitizer = kit.fetch :sanitizer
+
+        def colorizer = kit.fetch :colorizer
+      end
+    end
+  end
+end

data/lib/cogger/formatters/simple.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    # Formats simple templates that require no additional processing.
+    class Simple
+      TEMPLATE = "%<message>s"
+
+      def initialize template = TEMPLATE, sanitizer: Kit::Sanitizer.new
+        @template = template
+        @sanitizer = sanitizer
+      end
+
+      def call(*entry) = "#{format template, sanitizer.call(*entry)}\n"
+
+      private
+
+      attr_reader :template, :sanitizer
+    end
+  end
+end

data/lib/cogger/hub.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Cogger
+  # Loads configuration and simultaneously sends messages to multiple streams.
+  class Hub
+    def initialize(registry: Cogger, model: Configuration.new, **attributes)
+      @registry = registry
+      @configuration = model.with(**transform(attributes))
+      @mutex = Mutex.new
+      @streams = [configuration.to_logger]
+    end
+
+    def add_stream **attributes
+      attributes[:id] = configuration.id
+      streams.append configuration.with(**transform(attributes)).to_logger
+      self
+    end
+
+    def debug(...) = log(__method__, ...)
+
+    def info(...) = log(__method__, ...)
+
+    def warn(...) = log(__method__, ...)
+
+    def error(...) = log(__method__, ...)
+
+    def fatal(...) = log(__method__, ...)
+
+    def unknown(...) = log(__method__, ...)
+
+    alias any unknown
+
+    def inspect
+      %(#<#{self.class} #{configuration.inspect.delete_prefix! "#<Cogger::Configuration "})
+    end
+
+    private
+
+    attr_reader :registry, :configuration, :mutex, :streams
+
+    # :reek:FeatureEnvy
+    # :reek:TooManyStatements
+    def transform attributes
+      value = attributes[:formatter]
+
+      return attributes unless value.is_a?(Symbol) || value.is_a?(String)
+
+      formatter, template = registry.get_formatter value
+      attributes[:formatter] = template ? formatter.new(template) : formatter.new
+      attributes
+    end
+
+    # :reek:TooManyStatements
+    def log(severity, message = nil, &)
+      mutex.synchronize { streams.each { |logger| logger.public_send(severity, message, &) } }
+      true
+    rescue StandardError => error
+      configuration.with(id: "Cogger", io: $stdout, formatter: Formatters::Crash.new)
+                   .to_logger
+                   .fatal message:,
+                          error_message: error.message,
+                          error_class: error.class,
+                          backtrace: error.backtrace
+      true
+    end
+  end
+end

data/lib/cogger/program.rb

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

data/lib/cogger/registry.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "tone"
+
+module Cogger
+  # Provides a global regsitry for global configuration.
+  module Registry
+    def self.extended target
+      target.add_alias(:debug, :white)
+            .add_alias(:info, :green)
+            .add_alias(:warn, :yellow)
+            .add_alias(:error, :red)
+            .add_alias(:fatal, *%i[bold white on_red])
+            .add_alias(:unknown, *%i[bold white])
+            .add_alias(:any, *%i[bold white])
+            .add_emoji(:debug, "🔎")
+            .add_emoji(:info, "🟢")
+            .add_emoji(:warn, "⚠️ ")
+            .add_emoji(:error, "🛑")
+            .add_emoji(:fatal, "🔥")
+            .add_filter(:_csrf)
+            .add_filter(:password)
+            .add_filter(:password_confirmation)
+            .add_formatter(:color, Cogger::Formatters::Color)
+            .add_formatter(
+              :detail,
+              Cogger::Formatters::Simple,
+              "[%<id>s] [%<severity>s] [%<at>s] %<message>s"
+            )
+            .add_formatter(
+              :emoji,
+              Cogger::Formatters::Color,
+              "%<emoji:dynamic>s %<message:dynamic>s"
+            )
+            .add_formatter(:json, Cogger::Formatters::JSON)
+            .add_formatter(:simple, Cogger::Formatters::Simple)
+            .add_formatter :rack,
+                           Cogger::Formatters::Simple,
+                           "[%<id>s] [%<severity>s] [%<at>s] %<verb>s %<status>s %<duration>s " \
+                           "%<ip>s %<path>s %<length>s %<params>s"
+    end
+
+    def add_alias(key, *styles)
+      color.add_alias(key, *styles)
+      self
+    end
+
+    def aliases = color.aliases
+
+    def add_emoji key, value
+      emojis[key.to_sym] = value
+      self
+    end
+
+    def get_emoji(key) = emojis[key.to_sym]
+
+    def emojis = @emojis ||= {}
+
+    def add_filter key
+      filters.add key.to_sym
+      self
+    end
+
+    def filters = @filters ||= Set.new
+
+    def add_formatter key, formatter, template = nil
+      formatters[key.to_sym] = [formatter, template]
+      self
+    end
+
+    def get_formatter(key) = formatters[key.to_sym]
+
+    def formatters = @formatters ||= {}
+
+    def color = @color ||= Tone.new
+
+    def defaults = {emojis: emojis.dup, formatters: formatters.dup}
+  end
+end

data/lib/cogger.rb

@@ -2,9 +2,19 @@
 
 require "zeitwerk"
 
-Zeitwerk::Loader.for_gem.setup
+Zeitwerk::Loader.for_gem.then do |loader|
+  loader.inflector.inflect "json" => "JSON"
+  loader.setup
+end
 
 # Main namespace.
 module Cogger
-  def self.init(...) = Client.new(...)
+  extend Registry
+
+  def self.init(...)
+    warn "#{self}##{__method__} is deprecated, use `.new` instead.", category: :deprecated
+    Client.new(...)
+  end
+
+  def self.new(...) = Hub.new(...)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cogger
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Brooke Kuhlmann
@@ -10,56 +10,47 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDdjCCAl6gAwIBAgIBATANBgkqhkiG9w0BAQsFADBBMQ8wDQYDVQQDDAZicm9v
+  MIIEeDCCAuCgAwIBAgIBATANBgkqhkiG9w0BAQsFADBBMQ8wDQYDVQQDDAZicm9v
   a2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQBGRYC
-  aW8wHhcNMjMwMzIyMDI1MDUzWhcNMjQwMzIxMDI1MDUzWjBBMQ8wDQYDVQQDDAZi
+  aW8wHhcNMjMwMzIyMTYxNDQxWhcNMjUwMzIxMTYxNDQxWjBBMQ8wDQYDVQQDDAZi
   cm9va2UxGjAYBgoJkiaJk/IsZAEZFgphbGNoZW1pc3RzMRIwEAYKCZImiZPyLGQB
-  GRYCaW8wggEgMA0GCSqGSIb3DQEBAQUAA4IBDQAwggEIAoIBAQDN48o0vC52F2Tm
-  +GVuhHer6sZx58nshIUHVXbD/4y5Xd798rmAtPMlwFEyvvx68wqvS+Wv96T7FckJ
-  1GxNDo7Sr9qtX/ZuFtGXuR9XLiffHB9OS/66XsbGEa3JbhWzvM3wEvGbI/mmzuCC
-  lWhcu4fsGYSwBtDdu1sXXDBzw2fPvQMSUg1pTczZritU2loGIk13u2Swic1b1t+g
-  M90d9DIWUruyMvXvTlWwmgR5TJJBWmdN28r1AeK+CK4JuKtcmrbVRm5pJu/NCEVY
-  GK2pW2GNyH/Uhr3GURG/62CTZajgasAPCMRA6fDF3qMC5x7k8VIBHHI4C9Q+ZxMZ
-  bf2f5LDFAgEjo3sweTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU
-  o8O4DUt12YAn26VApVf0Ay2LPaQwHwYDVR0RBBgwFoEUYnJvb2tlQGFsY2hlbWlz
-  dHMuaW8wHwYDVR0SBBgwFoEUYnJvb2tlQGFsY2hlbWlzdHMuaW8wDQYJKoZIhvcN
-  AQELBQADggEBAMu9b3FOh7yAIsUwpdqRaUbqNcLkfdHOO6siBKjQmyNwXwuNsL3K
-  jrlf1cZjK4k7pfLnDQOh2y519gjYI5a89BO1y/kHIa+2gxYOcBYFnxwhYkeCElw7
-  M7IF60Kx1oA+CAnHKQiZhYza3oPqq+HnXEIaQ1yotEEGFPexrVjPT3tswNkt0MUh
-  3VkmTWI8jdDdgVWe6VYA/SbV66QKMfjo6FhQOAg3r/j61p8ZrYSif9jupwwR/vPW
-  PeEy3IGK1LEEwzEikz3Q0ebJHITVsm7UFiyrOn2Wk2Omh33+G65HC/cXRK8h1bLM
-  mBOOp3pATPxRweMKsY4hosuFEwweI8Btwaw=
+  GRYCaW8wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCro8tj5/E1Hg88
+  f4qfiwPVd2zJQHvdYt4GHVvuHRRgx4HGhJuNp+4BId08RBn7V6V1MW6MY3kezRBs
+  M+7QOQ4b1xNLTvY7FYQB1wGK5a4x7TTokDrPYQxDB2jmsdDYCzVbIMrAvUfcecRi
+  khyGZCdByiiCl4fKv77P12tTT+NfsvXkLt/AYCGwjOUyGKTQ01Z6eC09T27GayPH
+  QQvIkakyFgcJtzSyGzs8bzK5q9u7wQ12MNTjJoXzW69lqp0oNvDylu81EiSUb5S6
+  QzzPxZBiRB1sgtbt1gUbVI262ZDq1gR+HxPFmp+Cgt7ZLIJZAtesQvtcMzseXpfn
+  hpmm0Sw22KGhRAy/mqHBRhDl5HqS1SJp2Ko3lcnpXeFResp0HNlt8NSu13vhC08j
+  GUHU9MyIXbFOsnp3K3ADrAVjPWop8EZkmUR3MV/CUm00w2cZHCSGiXl1KMpiVKvk
+  Ywr1gd2ZME4QLSo+EXUtLxDUa/W3xnBS8dBOuMMz02FPWYr3PN8CAwEAAaN7MHkw
+  CQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFAFgmv0tYMZnItuPycSM
+  F5wykJEVMB8GA1UdEQQYMBaBFGJyb29rZUBhbGNoZW1pc3RzLmlvMB8GA1UdEgQY
+  MBaBFGJyb29rZUBhbGNoZW1pc3RzLmlvMA0GCSqGSIb3DQEBCwUAA4IBgQAX+EGY
+  9RLYGxF1VLZz+G1ACQc4uyrCB6kXwI06kzUa5dF9tPXqTX9ffnz3/W8ck2IQhKzu
+  MKO2FVijzbDWTsZeZGglS4E+4Jxpau1lU9HhOIcKolv6LeC6UdALTFudY+GLb8Xw
+  REXgaJkjzzhkUSILmEnRwEbY08dVSl7ZAaxVI679vfI2yapLlIwpbBgmQTiTvPr3
+  qyyLUno9flYEOv9fmGHunSrM+gE0/0niGTXa5GgXBXYGS2he4LQGgSBfGp/cTwMU
+  rDKJRcusZ12lNBeDfgqACz/BBJF8FLodgk6rGMRZz7+ZmjjHEmpG5bQpR6Q2BuWL
+  XMtYk/QzaWuhiR7pWjiF8jbdd7RO6or0ohq7iFkokz/5xrtQ/vPzU2RQ3Qc6YaKw
+  3n5C8/6Zh9DYTkpcwPSuIfAga6wf4nXc9m6JAw8AuMLaiWN/r/2s4zJsUHYERJEu
+  gZGm4JqtuSg8pYjPeIJxS960owq+SfuC+jxqmRA54BisFCv/0VOJi7tiJVY=
   -----END CERTIFICATE-----
-date: 2023-03-22 00:00:00.000000000 Z
+date: 2023-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pastel
+  name: tone
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
-- !ruby/object:Gem::Dependency
-  name: refinements
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -88,7 +79,20 @@ files:
 - cogger.gemspec
 - lib/cogger.rb
 - lib/cogger/client.rb
-- lib/cogger/color.rb
+- lib/cogger/configuration.rb
+- lib/cogger/formatters/color.rb
+- lib/cogger/formatters/crash.rb
+- lib/cogger/formatters/json.rb
+- lib/cogger/formatters/kit/colorizer.rb
+- lib/cogger/formatters/kit/sanitizer.rb
+- lib/cogger/formatters/parsers/dynamic.rb
+- lib/cogger/formatters/parsers/individual.rb
+- lib/cogger/formatters/parsers/universal.rb
+- lib/cogger/formatters/processors/color.rb
+- lib/cogger/formatters/simple.rb
+- lib/cogger/hub.rb
+- lib/cogger/program.rb
+- lib/cogger/registry.rb
 homepage: https://alchemists.io/projects/cogger
 licenses:
 - Hippocratic-2.1
@@ -115,8 +119,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: Decorates native logging with colorized output.
+summary: A customizable logger.
 test_files: []