cmdx 1.1.0 → 1.1.1

data/lib/cmdx/fault.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module CMDx
-  # Exception class for task execution faults with result context.
+  # Base fault class for handling task execution failures and interruptions.
   #
-  # Fault provides a specialized exception that carries task execution context
-  # including the failed result, task instance, and execution chain. It serves
-  # as the base class for specific fault types and provides factory methods
-  # for creating fault instances and conditional fault matchers.
+  # 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,
@@ -15,20 +16,16 @@ module CMDx
     # @return [CMDx::Result] the result object that caused this fault
     attr_reader :result
 
-    # Creates a new fault instance with the given result context.
+    # Creates a new fault instance from a task execution result.
     #
-    # The fault message is derived from the result's metadata reason or falls
-    # back to a default internationalized message if no reason is provided.
+    # @param result [CMDx::Result] the task result that caused the fault
     #
-    # @param result [CMDx::Result] the failed task result that caused this fault
+    # @return [CMDx::Fault] the newly created fault instance
     #
-    # @return [Fault] the newly created fault instance
-    #
-    # @example Create a fault from a failed result
-    #   result = CMDx::Result.new(task)
-    #   result.fail!(reason: "Database connection failed")
+    # @example Create fault from failed task result
+    #   result = SomeTask.call(invalid_data: true)
     #   fault = CMDx::Fault.new(result)
-    #   fault.message # => "Database connection failed"
+    #   fault.task #=> SomeTask instance
     def initialize(result)
       @result = result
       super(result.metadata[:reason] || I18n.t("cmdx.faults.unspecified", default: "no reason given"))
@@ -36,23 +33,27 @@ module CMDx
 
     class << self
 
-      # Builds a fault instance based on the result's status.
+      # Builds a specific fault type based on the result's status.
       #
-      # Creates a specific fault subclass by capitalizing the result status
-      # and looking up the corresponding fault class constant. This allows
-      # for status-specific fault types like Failed, Skipped, etc.
+      # 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 failed task result
+      # @param result [CMDx::Result] the task result to build a fault from
       #
-      # @return [Fault] a fault instance of the appropriate subclass
+      # @return [CMDx::Fault] an instance of the appropriate fault subclass
       #
       # @raise [NameError] if no fault class exists for the result status
       #
-      # @example Build a fault for a failed result
-      #   result = CMDx::Result.new(task)
-      #   result.fail!
+      # @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
+      #   fault.class #=> CMDx::Failed
       def build(result)
         fault = CMDx.const_get(result.status.capitalize)
         fault.new(result)
@@ -60,19 +61,28 @@ module CMDx
 
       # Creates a fault matcher that matches faults from specific task classes.
       #
-      # Returns a temporary fault class that can be used in rescue clauses
-      # to catch faults only from the specified task types. The matcher uses
-      # the === operator to check if the fault's task is an instance of any
-      # of the given 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>] task classes to match against
+      # @param tasks [Array<Class>] one or more task classes to match against
       #
-      # @return [Class] a temporary fault class that matches the specified tasks
+      # @return [Class] a fault matcher class that responds to case equality
       #
-      # @example Match faults from specific task classes
-      #   rescue CMDx::Fault.for?(UserCreateTask, UserUpdateTask) => fault
-      #     # Handle faults only from user-related tasks
-      #     logger.error "User operation failed: #{fault.message}"
+      # @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
@@ -84,22 +94,33 @@ module CMDx
         temp_fault.tap { |c| c.instance_variable_set(:@tasks, tasks) }
       end
 
-      # Creates a fault matcher that matches faults based on a custom condition.
+      # Creates a fault matcher using a custom block for matching criteria.
       #
-      # Returns a temporary fault class that can be used in rescue clauses
-      # to catch faults that satisfy the given block condition. The matcher
-      # uses the === operator to evaluate the block against the fault instance.
+      # 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] the condition block to evaluate against fault instances
+      # @param block [Proc] a block that receives a fault and returns boolean
       #
-      # @return [Class] a temporary fault class that matches the block condition
+      # @return [Class] a fault matcher class that responds to case equality
       #
       # @raise [ArgumentError] if no block is provided
       #
-      # @example Match faults based on custom condition
-      #   rescue CMDx::Fault.matches? { |f| f.task.context.user_id == current_user.id } => fault
-      #     # Handle faults only for current user's operations
-      #     notify_user_of_failure(fault)
+      # @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?

data/lib/cmdx/immutator.rb

@@ -1,39 +1,38 @@
 # frozen_string_literal: true
 
 module CMDx
-  # Freezes task objects after execution to ensure immutability.
+  # Provides object immutability functionality for tasks and their associated objects.
   #
-  # This module provides the final step in the task lifecycle by freezing
-  # task instances and their associated objects to prevent further modification.
-  # The freezing behavior can be controlled via environment variables and
-  # is conditionally applied based on the task's position in the execution chain.
+  # 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 task objects after execution to make them immutable.
+    # Freezes a task and its associated objects to prevent further modification.
     #
-    # Always freezes the task and its result. For the first task in a chain
-    # (index 0), also freezes the context and chain, then clears the chain.
-    # Freezing can be skipped entirely by setting the SKIP_CMDX_FREEZING
-    # environment variable to a truthy value.
+    # 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 [Task] the task instance to freeze after execution
+    # @param task [CMDx::Task] the task instance to freeze along with its associated objects
     #
-    # @return [nil] always returns nil
+    # @return [void] returns nil when freezing is skipped, otherwise no meaningful return value
     #
-    # @raise [StandardError] if any freeze operation fails
-    #
-    # @example Freeze a completed task
-    #   task = MyTask.new(user_id: 123)
-    #   task.process
+    # @example Freeze a task after execution
+    #   task = MyTask.call(user_id: 123)
     #   CMDx::Immutator.call(task)
-    #   task.frozen? # => true
+    #   task.frozen? #=> true
+    #   task.result.frozen? #=> true
     #
-    # @example Skip freezing for testing
-    #   ENV["SKIP_CMDX_FREEZING"] = "1"
+    # @example Skip freezing during testing
+    #   ENV["SKIP_CMDX_FREEZING"] = "true"
+    #   task = MyTask.call(user_id: 123)
     #   CMDx::Immutator.call(task)
-    #   task.frozen? # => false
+    #   task.frozen? #=> false
     def call(task)
       # Stubbing on frozen objects is not allowed
       skip_freezing = ENV.fetch("SKIP_CMDX_FREEZING", false)

data/lib/cmdx/lazy_struct.rb

@@ -1,29 +1,28 @@
 # frozen_string_literal: true
 
 module CMDx
-  # Hash-like data structure with dynamic attribute access and automatic key normalization.
+  # Flexible struct-like object with symbol-based attribute access and dynamic assignment.
   #
-  # LazyStruct provides a flexible data container that combines hash-like access patterns
-  # with dynamic method calls. All keys are automatically converted to symbols for
-  # consistent access, and the structure supports both bracket notation and method-style
-  # attribute access through method_missing.
+  # 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 from the provided arguments.
+    # Creates a new LazyStruct instance with the provided attributes.
     #
-    # @param args [Hash, #to_h] initial data for the structure, must respond to to_h
+    # @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 data
+    # @example Create with hash attributes
     #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.name # => "John"
+    #   struct.name #=> "John"
     #
     # @example Create with hash-like object
     #   struct = LazyStruct.new(OpenStruct.new(status: "active"))
-    #   struct.status # => "active"
+    #   struct.status #=> "active"
     def initialize(args = {})
       unless args.respond_to?(:to_h)
         raise ArgumentError,
@@ -35,34 +34,36 @@ module CMDx
 
     # Retrieves the value for the specified key.
     #
-    # @param key [Symbol, String] the key to retrieve
+    # @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 existing key
+    # @example Access attribute by symbol
     #   struct = LazyStruct.new(name: "John")
-    #   struct[:name] # => "John"
-    #   struct["name"] # => "John"
+    #   struct[:name] #=> "John"
+    #
+    # @example Access attribute by string
+    #   struct[:name] #=> "John"
+    #   struct["name"] #=> "John"
     def [](key)
       table[symbolized_key(key)]
     end
 
-    # Fetches the value for the specified key with optional default handling.
+    # Retrieves the value for the specified key or returns/yields a default.
     #
-    # @param key [Symbol, String] the key to fetch
-    # @param args [Array] optional default value or block arguments
+    # @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 if not found
+    # @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!(:name) # => "John"
-    #   struct.fetch!(:missing, "default") # => "default"
+    #   struct.fetch!(:age, 25) #=> 25
     #
-    # @example Fetch with block
-    #   struct.fetch!(:missing) { "computed default" } # => "computed default"
+    # @example Fetch with block default
+    #   struct.fetch!(:missing) { "default" } #=> "default"
     def fetch!(key, ...)
       table.fetch(symbolized_key(key), ...)
     end
@@ -76,107 +77,115 @@ module CMDx
     #
     # @example Store a value
     #   struct = LazyStruct.new
-    #   struct.store!(:name, "John") # => "John"
-    #   struct[:name] # => "John"
+    #   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 current structure.
+    # Merges the provided arguments into the struct's attributes.
     #
-    # @param args [Hash, #to_h] the data to merge, must respond to to_h
+    # @param args [Hash, #to_h] attributes to merge into the struct
     #
-    # @return [LazyStruct] returns self for method chaining
+    # @return [LazyStruct] self for method chaining
     #
-    # @example Merge additional data
+    # @example Merge attributes
     #   struct = LazyStruct.new(name: "John")
     #   struct.merge!(age: 30, city: "NYC")
-    #   struct.age # => 30
+    #   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 structure.
+    # Deletes the specified key from the struct.
     #
     # @param key [Symbol, String] the key to delete
-    # @param block [Proc] optional block to execute if key is not found
+    # @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 a key
+    # @example Delete an attribute
     #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.delete!(:age) # => 30
-    #   struct.age # => nil
+    #   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 LazyStruct instance.
+    # Checks equality with another object.
     #
-    # @param other [Object] the object to compare with
+    # @param other [Object] the object to compare against
     #
-    # @return [Boolean] true if both objects are LazyStruct instances with the same data
+    # @return [Boolean] true if other is a LazyStruct with identical attributes
     #
-    # @example Compare structures
+    # @example Compare structs
     #   struct1 = LazyStruct.new(name: "John")
     #   struct2 = LazyStruct.new(name: "John")
-    #   struct1.eql?(struct2) # => true
+    #   struct1.eql?(struct2) #=> true
     def eql?(other)
       other.is_a?(self.class) && (to_h == other.to_h)
     end
     alias == eql?
 
-    # Extracts nested values using the specified key path.
+    # Extracts nested values using key path traversal.
     #
-    # @param key [Symbol, String] the first key in the path
-    # @param keys [Array] additional keys for nested access
+    # @param key [Symbol, String] the initial key to look up
+    # @param keys [Array<Symbol, String>] additional keys for nested traversal
     #
-    # @return [Object, nil] the value at the specified path, or nil if not found
+    # @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, :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 structure.
+    # Iterates over each key-value pair in the struct.
     #
-    # @param block [Proc] the block to execute for each pair
+    # @param block [Proc] the block to execute for each key-value pair
     #
-    # @return [LazyStruct] returns self if block given, otherwise returns enumerator
+    # @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
+    #   # Output: name: John
+    #   #         age: 30
     def each_pair(&)
       table.each_pair(&)
     end
 
-    # Converts the structure to a hash representation.
+    # Converts the struct to a hash representation.
     #
-    # @param block [Proc] optional block for hash transformation
+    # @param block [Proc] optional block for transforming key-value pairs
     #
-    # @return [Hash] hash representation of the structure
+    # @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}
+    #   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 structure.
+    # Returns a string representation of the struct for debugging.
     #
-    # @return [String] formatted string showing class name and key-value pairs
+    # @return [String] a formatted string showing the class name and attributes
     #
-    # @example Inspect structure
+    # @example Inspect struct
     #   struct = LazyStruct.new(name: "John", age: 30)
-    #   struct.inspect # => "#<CMDx::LazyStruct :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
@@ -184,50 +193,49 @@ module CMDx
 
     private
 
-    # Returns the internal hash table, initializing it if needed.
+    # Returns the internal hash table storing the struct's attributes.
     #
-    # @return [Hash] the internal hash storage
+    # @return [Hash] the internal attribute storage
     def table
       @table ||= {}
     end
 
-    # Provides dynamic method access to stored values and assignment.
+    # Handles dynamic method calls for attribute access and assignment.
     #
     # @param method_name [Symbol] the method name being called
-    # @param args [Array] method arguments
+    # @param args [Array] arguments passed to the method
     # @param _kwargs [Hash] keyword arguments (unused)
-    # @param block [Proc] optional block (unused)
+    # @param block [Proc] block passed to the method (unused)
     #
-    # @return [Object] the value for the method name, or result of assignment
+    # @return [Object, nil] the attribute value for getters, or the assigned value for setters
     #
-    # @example Dynamic method access
+    # @example Dynamic attribute access
     #   struct = LazyStruct.new(name: "John")
-    #   struct.name # => "John"
-    #   struct.age = 30
-    #   struct.age # => 30
+    #   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 structure responds to the specified method name.
+    # 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 method is available or key exists in structure
+    # @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 [Object] the key to convert to symbol
+    # @param key [Symbol, String, Object] the key to convert
     #
     # @return [Symbol] the symbolized key
     #
-    # @raise [TypeError] if key cannot be converted to symbol
+    # @raise [TypeError] if the key cannot be converted to a symbol
     def symbolized_key(key)
       key.to_sym
     rescue NoMethodError

data/lib/cmdx/log_formatters/json.rb

@@ -23,7 +23,7 @@ module CMDx
       # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::Json.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"
+      #   #=> "{\"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).merge!(
           severity:,

data/lib/cmdx/log_formatters/key_value.rb

@@ -23,7 +23,7 @@ module CMDx
       # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::KeyValue.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"
+      #   #=> "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).merge!(
           severity:,

data/lib/cmdx/log_formatters/line.rb

@@ -23,7 +23,7 @@ module CMDx
       # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::Line.new
       #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
-      #   # => "I, [2024-01-01T12:00:00.000Z #12345] INFO -- TaskClass: Task completed\n"
+      #   #=> "I, [2024-01-01T12:00:00.000Z #12345] INFO -- TaskClass: Task completed\n"
       def call(severity, time, task, message)
         t = Utils::LogTimestamp.call(time.utc)
         m = LoggerSerializer.call(severity, time, task, message)

data/lib/cmdx/log_formatters/logstash.rb

@@ -24,7 +24,7 @@ module CMDx
       # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::Logstash.new
       #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
-      #   # => "{\"severity\":\"INFO\",\"pid\":12345,\"@version\":\"1\",\"@timestamp\":\"2024-01-01T12:00:00.000Z\",\"message\":\"Task completed\"}\n"
+      #   #=> "{\"severity\":\"INFO\",\"pid\":12345,\"@version\":\"1\",\"@timestamp\":\"2024-01-01T12:00:00.000Z\",\"message\":\"Task completed\"}\n"
       def call(severity, time, task, message)
         m = LoggerSerializer.call(severity, time, task, message).merge!(
           severity:,

data/lib/cmdx/log_formatters/pretty_json.rb

@@ -24,7 +24,7 @@ module CMDx
       # @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"
+      #   #=> "{\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:,

data/lib/cmdx/log_formatters/pretty_key_value.rb

@@ -21,7 +21,7 @@ module CMDx
       # @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"
+      #   #=> "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:,

data/lib/cmdx/log_formatters/pretty_line.rb

@@ -25,7 +25,7 @@ module CMDx
       # @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"
+      #   #=> "\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)

data/lib/cmdx/log_formatters/raw.rb

@@ -22,12 +22,12 @@ module CMDx
       # @example Formatting a log entry
       #   formatter = CMDx::LogFormatters::Raw.new
       #   result = formatter.call("INFO", Time.now, task_object, "Task completed")
-      #   # => "\"Task completed\"\n"
+      #   #=> "\"Task completed\"\n"
       #
       # @example Formatting a complex object
       #   formatter = CMDx::LogFormatters::Raw.new
       #   result = formatter.call("DEBUG", Time.now, task_object, { status: :success, count: 42 })
-      #   # => "{:status=>:success, :count=>42}\n"
+      #   #=> "{:status=>:success, :count=>42}\n"
       def call(_severity, _time, _task, message)
         message.inspect + "\n" # rubocop:disable Style/StringConcatenation
       end