ruby-progress 1.3.1 → 1.3.4

data/lib/ruby-progress/utils.rb

@@ -13,12 +13,17 @@ module RubyProgress
     end
 
     def self.clear_line(output_stream = :stderr)
-      case output_stream
-      when :stdout
-        $stdout.print "\r\e[K"
-      else
-        $stderr.print "\r\e[K"
-      end
+      io = case output_stream
+           when :stdout
+             $stdout
+           when :stderr
+             $stderr
+           else
+             # allow passing an IO-like object (e.g. StringIO) directly
+             output_stream.respond_to?(:print) ? output_stream : $stderr
+           end
+
+      io.print "\r\e[K"
     end
 
     # Enhanced line clearing for daemon mode that handles output interruption
@@ -33,39 +38,55 @@ module RubyProgress
     # @param success [Boolean] Whether this represents success or failure
     # @param show_checkmark [Boolean] Whether to show checkmark/X symbols
     # @param output_stream [Symbol] Where to output (:stdout, :stderr, :warn)
-    def self.display_completion(message, success: true, show_checkmark: false, output_stream: :warn)
+    def self.display_completion(message, success: true, show_checkmark: false, output_stream: :warn, icons: {})
       return unless message
 
-      mark = ''
-      if show_checkmark
-        mark = success ? '✅ ' : '🛑 '
-      end
+      mark = if show_checkmark
+               icon = success ? (icons[:success] || '✅') : (icons[:error] || '🛑')
+               "#{icon} "
+             else
+               ''
+             end
 
       formatted_message = "#{mark}#{message}"
 
-      case output_stream
-      when :stdout
-        puts formatted_message
-      when :stderr
-        warn formatted_message
-      when :warn
-        # Ensure we're at the beginning of a fresh line, clear it, then display message
-        $stderr.print "\r\e[2K"
-        $stderr.flush
+      # Resolve destination IO: support symbols (:stdout/:stderr/:warn) or an IO-like object
+      dest_io = case output_stream
+                when :stdout
+                  $stdout
+                when :stderr
+                  $stderr
+                when :warn
+                  $stderr
+                else
+                  output_stream.respond_to?(:print) ? output_stream : $stderr
+                end
+
+      # Only treat explicit :stdout and :stderr as non-clearing requests.
+      # For :warn and any other/custom stream, clear the current line first.
+      unless %i[stdout stderr].include?(output_stream)
+        # Always include a leading carriage return when clearing to match
+        # terminal behavior expected by the test-suite.
+        dest_io.print "\r\e[2K"
+        dest_io.flush if dest_io.respond_to?(:flush)
+      end
+
+      # Emit the message to the resolved destination IO. Use warn/puts when targeting
+      # the standard streams to preserve familiar behavior (warn writes to $stderr).
+      if dest_io == $stdout
+        $stdout.puts formatted_message
+      elsif dest_io == $stderr
         warn formatted_message
       else
-        # Ensure we're at the beginning of a fresh line, clear it, then display message
-        $stderr.print "\r\e[2K"
-        $stderr.flush
-        warn formatted_message
+        dest_io.puts formatted_message
       end
     end
 
     # Clear current line and display completion message
     # Convenience method that combines line clearing with message display
-    def self.complete_with_clear(message, success: true, show_checkmark: false, output_stream: :warn)
+    def self.complete_with_clear(message, success: true, show_checkmark: false, output_stream: :warn, icons: {})
       clear_line(output_stream) if output_stream != :warn # warn already includes clear in display_completion
-      display_completion(message, success: success, show_checkmark: show_checkmark, output_stream: output_stream)
+      display_completion(message, success: success, show_checkmark: show_checkmark, output_stream: output_stream, icons: icons)
     end
 
     # Parse start/end characters for animation wrapping

data/lib/ruby-progress/version.rb

@@ -2,11 +2,11 @@
 
 module RubyProgress
   # Main gem version
-  VERSION = '1.3.1'
+  VERSION = '1.3.4'
 
   # Component-specific versions (patch bumps)
-  WORM_VERSION = '1.1.3'
-  TWIRL_VERSION = '1.1.3'
-  RIPPLE_VERSION = '1.1.3'
-  FILL_VERSION = '1.0.3'
+  WORM_VERSION = '1.1.4'
+  TWIRL_VERSION = '1.1.4'
+  RIPPLE_VERSION = '1.1.4'
+  FILL_VERSION = '1.0.4'
 end

data/lib/ruby-progress/worm.rb

@@ -65,6 +65,9 @@ module RubyProgress
       @error_text = options[:error]
       @show_checkmark = options[:checkmark] || false
       @output_stdout = options[:stdout] || false
+      @output_lines = options[:output_lines]
+      @output_position = options[:output_position]
+      @output_live = options[:stdout_live] || false
       @direction_mode = options[:direction] || :bidirectional
       @start_chars, @end_chars = RubyProgress::Utils.parse_ends(options[:ends])
       @running = false
@@ -76,13 +79,14 @@ module RubyProgress
     def display_completion_message(message, success)
       return unless message
 
-      mark = ''
-      if @show_checkmark
-        mark = success ? '✅ ' : '🛑 '
-      end
-
-      # Clear animation line and output completion message on stderr
-      $stderr.print "\r\e[2K#{mark}#{message}\n"
+      # Delegate to Utils.display_completion so carriage-return and clearing
+      # behavior is consistent across all indicators and respects TTY state.
+      RubyProgress::Utils.display_completion(
+        message,
+        success: success,
+        show_checkmark: @show_checkmark,
+        output_stream: :warn
+      )
     end
 
     def parse_speed(speed_input)
@@ -196,67 +200,11 @@ module RubyProgress
       }
     end
 
-    def animation_loop
-      position = 0
-      direction = 1
-
-      while @running
-        message_part = @message && !@message.empty? ? "#{@message} " : ''
-        # Enhanced line clearing for better daemon mode behavior
-        $stderr.print "\r\e[2K#{@start_chars}#{message_part}#{generate_dots(position, direction)}#{@end_chars}"
-        $stderr.flush
-
-        sleep @speed
-
-        position += direction
-        if position >= @length - 1
-          if @direction_mode == :forward_only
-            position = 0
-          else
-            direction = -1
-          end
-        elsif position <= 0
-          direction = 1
-        end
-      end
-    end
-
-    # Enhanced animation loop for daemon mode with aggressive line clearing
-    def animation_loop_daemon_mode(stop_requested_proc: -> { false })
-      position = 0
-      direction = 1
-      frame_count = 0
-
-      while @running && !stop_requested_proc.call
-        message_part = @message && !@message.empty? ? "#{@message} " : ''
-
-        # Always clear current line
-        $stderr.print "\r\e[2K"
-
-        # Every few frames, use aggressive clearing to handle interruptions
-        if (frame_count % 10).zero?
-          $stderr.print "\e[1A\e[2K"   # Move up and clear that line too (in case of interruption)
-          $stderr.print "\r"           # Return to start
-        end
-
-        $stderr.print "#{message_part}#{generate_dots(position, direction)}"
-        $stderr.flush
-
-        sleep @speed
-        frame_count += 1
-
-        position += direction
-        if position >= @length - 1
-          if @direction_mode == :forward_only
-            position = 0
-          else
-            direction = -1
-          end
-        elsif position <= 0
-          direction = 1
-        end
-      end
-    end
+    # animation_loop and animation_loop_daemon_mode are implemented in
+    # the WormRunner module so they can share the redraw behavior that
+    # integrates with RubyProgress::OutputCapture. Do not redefine them
+    # here, otherwise the module implementations (which call
+    # @output_capture&.redraw) will be overridden.
 
     def generate_dots(ripple_position, direction)
       dots = Array.new(@length) { @style[:baseline] }