cmdx 1.1.2 → 1.5.0

data/lib/cmdx/fault.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  # Base fault class for handling task execution failures and interruptions.
-  #
-  # Faults are exceptions raised when tasks encounter specific execution states
-  # that prevent normal completion. Unlike regular exceptions, faults carry
-  # rich context information including the task result, execution chain, and
-  # contextual data that led to the fault condition. Faults can be caught and
-  # handled based on specific task types or custom matching criteria.
-  class Fault < Error
-
-    cmdx_attr_delegator :task, :chain, :context,
-                        to: :result
-
-    # @return [CMDx::Result] the result object that caused this fault
-    attr_reader :result
-
-    # Creates a new fault instance from a task execution result.
-    #
-    # @param result [CMDx::Result] the task result that caused the fault
-    #
-    # @return [CMDx::Fault] the newly created fault instance
-    #
-    # @example Create fault from failed task result
-    #   result = SomeTask.call(invalid_data: true)
-    #   fault = CMDx::Fault.new(result)
-    #   fault.task #=> SomeTask instance
-    def initialize(result)
-      @result = result
-      super(result.metadata[:reason] || I18n.t("cmdx.faults.unspecified", default: "no reason given"))
-    end
-
-    class << self
-
-      # Builds a specific fault type based on the result's status.
-      #
-      # Creates an instance of the appropriate fault subclass (Skipped, Failed, etc.)
-      # by capitalizing the result status and looking up the corresponding fault class.
-      # This provides dynamic fault creation based on task execution outcomes.
-      #
-      # @param result [CMDx::Result] the task result to build a fault from
-      #
-      # @return [CMDx::Fault] an instance of the appropriate fault subclass
-      #
-      # @raise [NameError] if no fault class exists for the result status
-      #
-      # @example Build fault from skipped task result
-      #   result = SomeTask.call # result.status is :skipped
-      #   fault = CMDx::Fault.build(result)
-      #   fault.class #=> CMDx::Skipped
-      #
-      # @example Build fault from failed task result
-      #   result = SomeTask.call # result.status is :failed
-      #   fault = CMDx::Fault.build(result)
-      #   fault.class #=> CMDx::Failed
-      def build(result)
-        fault = CMDx.const_get(result.status.capitalize)
-        fault.new(result)
-      end
-
-      # Creates a fault matcher that matches faults from specific task classes.
-      #
-      # Returns a dynamically created fault class that can be used in rescue blocks
-      # to catch faults only when they originate from specific task types. This enables
-      # selective fault handling based on the task that generated the fault.
-      #
-      # @param tasks [Array<Class>] one or more task classes to match against
-      #
-      # @return [Class] a fault matcher class that responds to case equality
-      #
-      # @example Catch faults from specific task types
-      #   begin
-      #     PaymentTask.call!
-      #   rescue CMDx::Fault.for?(PaymentTask, RefundTask) => e
-      #     puts "Payment operation failed: #{e.message}"
-      #   end
-      #
-      # @example Match faults from multiple task types
-      #   UserTaskFaults = CMDx::Fault.for?(CreateUserTask, UpdateUserTask, DeleteUserTask)
-      #
-      #   begin
-      #     workflow.call!
-      #   rescue CMDx::Fault.for?(CreateUserTask, UpdateUserTask, DeleteUserTask) => e
-      #     handle_user_operation_failure(e)
-      #   end
-      def for?(*tasks)
-        temp_fault = Class.new(self) do
-          def self.===(other)
-            other.is_a?(superclass) && @tasks.any? { |task| other.task.is_a?(task) }
-          end
-        end
-
-        temp_fault.tap { |c| c.instance_variable_set(:@tasks, tasks) }
-      end
-
-      # Creates a fault matcher using a custom block for matching criteria.
-      #
-      # Returns a dynamically created fault class that uses the provided block
-      # to determine if a fault should be matched. The block receives the fault
-      # instance and should return true if the fault matches the desired criteria.
-      # This enables custom fault handling logic beyond simple task type matching.
-      #
-      # @param block [Proc] a block that receives a fault and returns boolean
-      #
-      # @return [Class] a fault matcher class that responds to case equality
-      #
-      # @raise [ArgumentError] if no block is provided
-      #
-      # @example Match faults by custom criteria
-      #   begin
-      #     LongRunningTask.call!
-      #   rescue CMDx::Fault.matches? { |fault| fault.context[:timeout_exceeded] } => e
-      #     puts "Task timed out: #{e.message}"
-      #   end
-      #
-      # @example Match faults by metadata content
-      #   ValidationFault = CMDx::Fault.matches? { |fault| fault.result.metadata[:type] == "validation_error" }
-      #
-      #   begin
-      #     ValidateUserTask.call!
-      #   rescue ValidationFault => e
-      #     display_validation_errors(e.result.errors)
-      #   end
-      def matches?(&block)
-        raise ArgumentError, "block required" unless block_given?
-
-        temp_fault = Class.new(self) do
-          def self.===(other)
-            other.is_a?(superclass) && @block.call(other)
-          end
-        end
-
-        temp_fault.tap { |c| c.instance_variable_set(:@block, block) }
-      end
-
-    end
-
-  end
-end

data/lib/cmdx/immutator.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  # Provides object immutability functionality for tasks and their associated objects.
-  #
-  # This module freezes task objects and their related components after execution
-  # to prevent unintended modifications. It supports conditional freezing through
-  # environment variable configuration, allowing developers to disable immutability
-  # during testing scenarios where object stubbing is required.
-  module Immutator
-
-    module_function
-
-    # Freezes a task and its associated objects to prevent further modification.
-    #
-    # This method makes the task, its result, and related objects immutable after
-    # execution. If the task result index is zero (indicating the first task in a chain),
-    # it also freezes the context and chain objects. The freezing behavior can be
-    # disabled via the SKIP_CMDX_FREEZING environment variable for testing purposes.
-    #
-    # @param task [CMDx::Task] the task instance to freeze along with its associated objects
-    #
-    # @return [void] returns nil when freezing is skipped, otherwise no meaningful return value
-    #
-    # @example Freeze a task after execution
-    #   task = MyTask.call(user_id: 123)
-    #   CMDx::Immutator.call(task)
-    #   task.frozen? #=> true
-    #   task.result.frozen? #=> true
-    #
-    # @example Skip freezing during testing
-    #   ENV["SKIP_CMDX_FREEZING"] = "true"
-    #   task = MyTask.call(user_id: 123)
-    #   CMDx::Immutator.call(task)
-    #   task.frozen? #=> false
-    def call(task)
-      # Stubbing on frozen objects is not allowed
-      skip_freezing = ENV.fetch("SKIP_CMDX_FREEZING", false)
-      return if Coercions::Boolean.call(skip_freezing)
-
-      task.freeze
-      task.result.freeze
-      return unless task.result.index.zero?
-
-      task.context.freeze
-      task.chain.freeze
-
-      Chain.clear
-    end
-
-  end
-end

data/lib/cmdx/lazy_struct.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  # Flexible struct-like object with symbol-based attribute access and dynamic assignment.
-  #
-  # LazyStruct provides a hash-like object that automatically converts string keys to symbols
-  # and supports both hash-style and method-style attribute access. It's designed for
-  # storing and accessing dynamic attributes with lazy evaluation and flexible assignment patterns.
-  class LazyStruct
-
-    # Creates a new LazyStruct instance with the provided attributes.
-    #
-    # @param args [Hash, #to_h] initial attributes for the struct
-    #
-    # @return [LazyStruct] a new LazyStruct instance
-    #
-    # @raise [ArgumentError] if args doesn't respond to to_h
-    #
-    # @example Create with hash attributes
-    #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.name #=> "John"
-    #
-    # @example Create with hash-like object
-    #   struct = LazyStruct.new(OpenStruct.new(status: "active"))
-    #   struct.status #=> "active"
-    def initialize(args = {})
-      unless args.respond_to?(:to_h)
-        raise ArgumentError,
-              "must be respond to `to_h`"
-      end
-
-      @table = args.to_h.transform_keys { |k| symbolized_key(k) }
-    end
-
-    # Retrieves the value for the specified key.
-    #
-    # @param key [Symbol, String] the key to look up
-    #
-    # @return [Object, nil] the value associated with the key, or nil if not found
-    #
-    # @example Access attribute by symbol
-    #   struct = LazyStruct.new(name: "John")
-    #   struct[:name] #=> "John"
-    #
-    # @example Access attribute by string
-    #   struct[:name] #=> "John"
-    #   struct["name"] #=> "John"
-    def [](key)
-      table[symbolized_key(key)]
-    end
-
-    # Retrieves the value for the specified key or returns/yields a default.
-    #
-    # @param key [Symbol, String] the key to look up
-    # @param args [Array] additional arguments passed to Hash#fetch
-    #
-    # @return [Object] the value associated with the key, or default value
-    #
-    # @raise [KeyError] if key is not found and no default is provided
-    #
-    # @example Fetch with default value
-    #   struct = LazyStruct.new(name: "John")
-    #   struct.fetch!(:age, 25) #=> 25
-    #
-    # @example Fetch with block default
-    #   struct.fetch!(:missing) { "default" } #=> "default"
-    def fetch!(key, ...)
-      table.fetch(symbolized_key(key), ...)
-    end
-
-    # Stores a value for the specified key.
-    #
-    # @param key [Symbol, String] the key to store the value under
-    # @param value [Object] the value to store
-    #
-    # @return [Object] the stored value
-    #
-    # @example Store a value
-    #   struct = LazyStruct.new
-    #   struct.store!(:name, "John") #=> "John"
-    #   struct.name #=> "John"
-    def store!(key, value)
-      table[symbolized_key(key)] = value
-    end
-    alias []= store!
-
-    # Merges the provided arguments into the struct's attributes.
-    #
-    # @param args [Hash, #to_h] attributes to merge into the struct
-    #
-    # @return [LazyStruct] self for method chaining
-    #
-    # @example Merge attributes
-    #   struct = LazyStruct.new(name: "John")
-    #   struct.merge!(age: 30, city: "NYC")
-    #   struct.age #=> 30
-    def merge!(args = {})
-      args.to_h.each { |key, value| store!(symbolized_key(key), value) }
-      self
-    end
-
-    # Deletes the specified key from the struct.
-    #
-    # @param key [Symbol, String] the key to delete
-    # @param block [Proc] optional block to yield if key is not found
-    #
-    # @return [Object, nil] the deleted value, or result of block if key not found
-    #
-    # @example Delete an attribute
-    #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.delete!(:age) #=> 30
-    #   struct.age #=> nil
-    #
-    # @example Delete with default block
-    #   struct.delete!(:missing) { "not found" } #=> "not found"
-    def delete!(key, &)
-      table.delete(symbolized_key(key), &)
-    end
-    alias delete_field! delete!
-
-    # Checks equality with another object.
-    #
-    # @param other [Object] the object to compare against
-    #
-    # @return [Boolean] true if other is a LazyStruct with identical attributes
-    #
-    # @example Compare structs
-    #   struct1 = LazyStruct.new(name: "John")
-    #   struct2 = LazyStruct.new(name: "John")
-    #   struct1.eql?(struct2) #=> true
-    def eql?(other)
-      other.is_a?(self.class) && (to_h == other.to_h)
-    end
-    alias == eql?
-
-    # Extracts nested values using key path traversal.
-    #
-    # @param key [Symbol, String] the initial key to look up
-    # @param keys [Array<Symbol, String>] additional keys for nested traversal
-    #
-    # @return [Object, nil] the nested value, or nil if any key in the path is missing
-    #
-    # @example Dig into nested structure
-    #   struct = LazyStruct.new(user: { profile: { name: "John" } })
-    #   struct.dig(:user, :profile, :name) #=> "John"
-    #   struct.dig(:user, :missing, :name) #=> nil
-    def dig(key, *keys)
-      table.dig(symbolized_key(key), *keys)
-    end
-
-    # Iterates over each key-value pair in the struct.
-    #
-    # @param block [Proc] the block to execute for each key-value pair
-    #
-    # @return [Enumerator, LazyStruct] an enumerator if no block given, self otherwise
-    #
-    # @example Iterate over pairs
-    #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.each_pair { |key, value| puts "#{key}: #{value}" }
-    #   # Output: name: John
-    #   #         age: 30
-    def each_pair(&)
-      table.each_pair(&)
-    end
-
-    # Converts the struct to a hash representation.
-    #
-    # @param block [Proc] optional block for transforming key-value pairs
-    #
-    # @return [Hash] a hash containing all the struct's attributes
-    #
-    # @example Convert to hash
-    #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.to_h #=> { name: "John", age: 30 }
-    #
-    # @example Convert with transformation
-    #   struct.to_h { |k, v| [k.to_s, v.to_s] } #=> { "name" => "John", "age" => "30" }
-    def to_h(&)
-      table.to_h(&)
-    end
-
-    # Returns a string representation of the struct for debugging.
-    #
-    # @return [String] a formatted string showing the class name and attributes
-    #
-    # @example Inspect struct
-    #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.inspect #=> "#<CMDx::LazyStruct :name=\"John\" :age=30>"
-    def inspect
-      "#<#{self.class.name}#{table.map { |key, value| ":#{key}=#{value.inspect}" }.join(' ')}>"
-    end
-    alias to_s inspect
-
-    private
-
-    # Returns the internal hash table storing the struct's attributes.
-    #
-    # @return [Hash] the internal attribute storage
-    def table
-      @table ||= {}
-    end
-
-    # Handles dynamic method calls for attribute access and assignment.
-    #
-    # @param method_name [Symbol] the method name being called
-    # @param args [Array] arguments passed to the method
-    # @param _kwargs [Hash] keyword arguments (unused)
-    # @param block [Proc] block passed to the method (unused)
-    #
-    # @return [Object, nil] the attribute value for getters, or the assigned value for setters
-    #
-    # @example Dynamic attribute access
-    #   struct = LazyStruct.new(name: "John")
-    #   struct.name #=> "John"
-    #   struct.age = 30 #=> 30
-    def method_missing(method_name, *args, **_kwargs, &)
-      table.fetch(symbolized_key(method_name)) do
-        store!(method_name[0..-2], args.first) if method_name.end_with?("=")
-      end
-    end
-
-    # Checks if the struct responds to a method name.
-    #
-    # @param method_name [Symbol] the method name to check
-    # @param include_private [Boolean] whether to include private methods
-    #
-    # @return [Boolean] true if the struct has the attribute or responds to the method
-    def respond_to_missing?(method_name, include_private = false)
-      table.key?(symbolized_key(method_name)) || super
-    end
-
-    # Converts a key to a symbol for consistent internal storage.
-    #
-    # @param key [Symbol, String, Object] the key to convert
-    #
-    # @return [Symbol] the symbolized key
-    #
-    # @raise [TypeError] if the key cannot be converted to a symbol
-    def symbolized_key(key)
-      key.to_sym
-    rescue NoMethodError
-      raise TypeError, "#{key} is not a symbol nor a string"
-    end
-
-  end
-end

data/lib/cmdx/log_formatters/pretty_json.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  module LogFormatters
-    # Pretty JSON log formatter that outputs structured log entries as formatted JSON.
-    #
-    # This formatter converts log entries into pretty-printed JSON format with proper
-    # indentation and line breaks, including metadata such as severity, process ID,
-    # and timestamp. Each log entry is output as a multi-line JSON structure followed
-    # by a newline character, making it human-readable while maintaining structure.
-    class PrettyJson
-
-      # Formats a log entry as a pretty-printed JSON string.
-      #
-      # @param severity [String] the log severity level (e.g., "INFO", "ERROR")
-      # @param time [Time] the timestamp when the log entry was created
-      # @param task [Object] the task object associated with the log entry
-      # @param message [String] the log message content
-      #
-      # @return [String] the formatted pretty JSON log entry with trailing newline
-      #
-      # @raise [JSON::GeneratorError] if the log data cannot be serialized to JSON
-      #
-      # @example Formatting a log entry
-      #   formatter = CMDx::LogFormatters::PrettyJson.new
-      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
-      #   #=> "{\n  \"severity\": \"INFO\",\n  \"pid\": 12345,\n  \"timestamp\": \"2024-01-01T12:00:00Z\",\n  \"message\": \"Task completed\"\n}\n"
-      def call(severity, time, task, message)
-        m = LoggerSerializer.call(severity, time, task, message).merge!(
-          severity:,
-          pid: Process.pid,
-          timestamp: Utils::LogTimestamp.call(time.utc)
-        )
-
-        JSON.pretty_generate(m) << "\n"
-      end
-
-    end
-  end
-end

data/lib/cmdx/log_formatters/pretty_key_value.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  module LogFormatters
-    # Pretty key-value log formatter that outputs structured log entries as human-readable key=value pairs.
-    #
-    # This formatter converts log entries into a space-separated key=value format with ANSI coloring
-    # for enhanced readability in terminal output. Each log entry includes metadata such as severity,
-    # process ID, and timestamp, with each entry terminated by a newline character.
-    class PrettyKeyValue
-
-      # Formats a log entry as a colorized key=value string.
-      #
-      # @param severity [String] the log severity level (e.g., "INFO", "ERROR")
-      # @param time [Time] the timestamp when the log entry was created
-      # @param task [Object] the task object associated with the log entry
-      # @param message [String] the log message content
-      #
-      # @return [String] the formatted key=value log entry with ANSI colors and trailing newline
-      #
-      # @example Formatting a log entry
-      #   formatter = CMDx::LogFormatters::PrettyKeyValue.new
-      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
-      #   #=> "severity=INFO pid=12345 timestamp=2024-01-01T12:00:00Z message=Task completed\n"
-      def call(severity, time, task, message)
-        m = LoggerSerializer.call(severity, time, task, message, ansi_colorize: true).merge!(
-          severity:,
-          pid: Process.pid,
-          timestamp: Utils::LogTimestamp.call(time.utc)
-        )
-
-        m = m.map { |k, v| "#{k}=#{v}" }.join(" ") if m.is_a?(Hash)
-        m << "\n"
-      end
-
-    end
-  end
-end

data/lib/cmdx/log_formatters/pretty_line.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  module LogFormatters
-    # Pretty line log formatter that outputs human-readable log entries with ANSI colors.
-    #
-    # This formatter converts log entries into a traditional log line format with
-    # color-coded severity levels, timestamps, and process information. The output
-    # is designed to be easily readable in terminal environments that support ANSI
-    # color codes.
-    class PrettyLine
-
-      # Formats a log entry as a colorized human-readable line.
-      #
-      # @param severity [String] the log severity level (e.g., "INFO", "ERROR")
-      # @param time [Time] the timestamp when the log entry was created
-      # @param task [Object] the task object associated with the log entry
-      # @param message [String] the log message content
-      #
-      # @return [String] the formatted log line with ANSI colors and trailing newline
-      #
-      # @raise [NoMethodError] if the task object doesn't respond to class or name methods
-      # @raise [StandardError] if LoggerSerializer, LoggerAnsi, or LogTimestamp fail
-      #
-      # @example Formatting a log entry
-      #   formatter = CMDx::LogFormatters::PrettyLine.new
-      #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
-      #   #=> "\e[32mI\e[0m, [2024-01-01T12:00:00.000Z #12345] \e[32mINFO\e[0m -- MyTask: Task completed\n"
-      def call(severity, time, task, message)
-        i = LoggerAnsi.call(severity[0])
-        s = LoggerAnsi.call(severity)
-        t = Utils::LogTimestamp.call(time.utc)
-        m = LoggerSerializer.call(severity, time, task, message, ansi_colorize: true)
-        m = m.map { |k, v| "#{k}=#{v}" }.join(" ") if m.is_a?(Hash)
-
-        "#{i}, [#{t} ##{Process.pid}] #{s} -- #{task.class.name}: #{m}\n"
-      end
-
-    end
-  end
-end

data/lib/cmdx/logger.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  # Logger management module for configuring and retrieving task-specific loggers.
-  #
-  # This module provides functionality to extract and configure logger instances
-  # from task settings, applying formatter, level, and progname configurations
-  # when available. It serves as a central point for logger setup during task execution.
-  module Logger
-
-    module_function
-
-    # Configures and returns a logger instance for the given task.
-    #
-    # Extracts the logger from task settings and applies additional configuration
-    # such as formatter, log level, and progname if they are specified in the
-    # task's command settings. The progname is set to the task instance itself
-    # for better log traceability.
-    #
-    # @param task [Task] the task instance containing logger configuration settings
-    #
-    # @return [Logger, nil] the configured logger instance, or nil if no logger is set
-    #
-    # @example Configure logger for a task
-    #   class MyTask < CMDx::Task
-    #     cmd setting!(
-    #       logger: Logger.new($stdout),
-    #       log_level: Logger::DEBUG,
-    #       log_formatter: CMDx::LogFormatters::JSON.new
-    #     )
-    #   end
-    #
-    #   task = MyTask.call
-    #   logger = CMDx::Logger.call(task)
-    #   #=> Returns configured logger with DEBUG level and JSON formatter
-    def call(task)
-      logger = task.cmd_setting(:logger)
-
-      unless logger.nil?
-        logger.formatter = task.cmd_setting(:log_formatter) if task.cmd_setting?(:log_formatter)
-        logger.level     = task.cmd_setting(:log_level) if task.cmd_setting?(:log_level)
-        logger.progname  = task
-      end
-
-      logger
-    end
-
-  end
-end

data/lib/cmdx/logger_ansi.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  # ANSI color formatting for logger severity levels and text output.
-  #
-  # LoggerAnsi provides utility methods for applying ANSI color codes to logger
-  # severity indicators and general text formatting. It maps standard logger
-  # severity levels to appropriate colors for enhanced readability in terminal output,
-  # delegating actual color application to the AnsiColor utility module.
-  module LoggerAnsi
-
-    SEVERITY_COLORS = {
-      "D" => :blue,      # DEBUG
-      "I" => :green,     # INFO
-      "W" => :yellow,    # WARN
-      "E" => :red,       # ERROR
-      "F" => :magenta    # FATAL
-    }.freeze
-
-    module_function
-
-    # Applies ANSI color formatting to text based on severity level indication.
-    #
-    # This method extracts the color for the given text based on its first character
-    # (typically a severity indicator) and applies both the determined color and bold
-    # formatting using the AnsiColor utility. The method provides consistent color
-    # formatting for logger output across the CMDx framework.
-    #
-    # @param s [String] the text to format, typically starting with a severity indicator
-    #
-    # @return [String] the formatted text with ANSI color and bold styling applied
-    #
-    # @example Format debug severity text
-    #   LoggerAnsi.call("DEBUG: Starting process") #=> "\e[1;34;49mDEBUG: Starting process\e[0m"
-    #
-    # @example Format error severity text
-    #   LoggerAnsi.call("ERROR: Operation failed") #=> "\e[1;31;49mERROR: Operation failed\e[0m"
-    #
-    # @example Format text with unknown severity
-    #   LoggerAnsi.call("CUSTOM: Message") #=> "\e[1;39;49mCUSTOM: Message\e[0m"
-    def call(s)
-      Utils::AnsiColor.call(s, color: color(s), mode: :bold)
-    end
-
-    # Determines the appropriate color for text based on its severity indicator.
-    #
-    # This method extracts the first character from the provided text and maps it
-    # to a corresponding color defined in SEVERITY_COLORS. If no matching severity
-    # is found, it returns the default color to ensure consistent formatting behavior.
-    #
-    # @param s [String] the text to analyze, typically starting with a severity indicator
-    #
-    # @return [Symbol] the color symbol corresponding to the severity level, or :default if not found
-    #
-    # @example Get color for debug severity
-    #   LoggerAnsi.color("DEBUG: Message") #=> :blue
-    #
-    # @example Get color for error severity
-    #   LoggerAnsi.color("ERROR: Failed") #=> :red
-    #
-    # @example Get color for unknown severity
-    #   LoggerAnsi.color("UNKNOWN: Text") #=> :default
-    def color(s)
-      SEVERITY_COLORS[s[0]] || :default
-    end
-
-  end
-end