ruby-progress 1.3.2 → 1.3.4

data/lib/ruby-progress/output_capture.rb

@@ -2,27 +2,69 @@
 
 require 'pty'
 require 'io/console'
-require 'English'
+require 'english'
+require 'fileutils'
+
+begin
+  require 'tty-cursor'
+  require 'tty-screen'
+rescue LoadError
+  # fall back to ANSI sequences when tty gems are not installed
+end
 
 module RubyProgress
-  # Simple PTY-based output capture that reserves a small area of the terminal
-  # for printing captured output while the animation is drawn separately.
+  # PTY-based live output capture that reserves a small terminal area
+  # for printing captured output while the animation draws elsewhere.
   class OutputCapture
     attr_reader :exit_status
 
-    def initialize(command:, lines: 3, position: :above, log_path: nil)
+    def initialize(command:, lines: 3, position: :above, log_path: nil, stream: false, debug: nil)
       @command = command
-      @lines = lines
-      @position = position
+      # Coerce lines into a positive Integer
+      @lines = (lines || 3).to_i
+      @lines = 1 if @lines < 1
+
+      # Normalize position (accept :top/:bottom or :above/:below or strings)
+      pos = position.respond_to?(:to_sym) ? position.to_sym : position
+      @position = case pos
+                  when :top, 'top' then :above
+                  when :bottom, 'bottom' then :below
+                  when :above, 'above' then :above
+                  when :below, 'below' then :below
+                  else
+                    :above
+                  end
+
       @buffer = []
       @buf_mutex = Mutex.new
       @stop = false
       @log_path = log_path
       @log_file = nil
+      @stream = stream
+
+      @debug = if debug.nil?
+                 ENV.fetch('RUBY_PROGRESS_DEBUG', nil) && ENV['RUBY_PROGRESS_DEBUG'] != '0'
+               else
+                 debug
+               end
+      @debug_path = '/tmp/ruby-progress-debug.log'
+
+      if @debug
+        begin
+          FileUtils.mkdir_p(File.dirname(@debug_path))
+          File.open(@debug_path, 'w') { |f| f.puts("debug start: #{Time.now}") }
+        rescue StandardError
+          @debug = false
+        end
+      end
+
+      # Debug: log init if requested via ENV or explicit debug flag
+      debug_log("init: position=#{@position.inspect}; lines=#{@lines}")
     end
 
-    # Start the child process and return a thread that manages capture.
+    # Start capturing the child process. Returns self.
     def start
+      reserve_space($stderr) if @stream
       @reader_thread = Thread.new { spawn_and_read }
       self
     end
@@ -32,45 +74,98 @@ module RubyProgress
       @reader_thread&.join
     end
 
-    # Wait for the reader thread to complete
     def wait
       @reader_thread&.join
     end
 
-    # Return snapshot of buffered lines (thread-safe)
     def lines
       @buf_mutex.synchronize { @buffer.dup }
     end
 
-    # Returns whether the reader thread is still alive
     def alive?
       @reader_thread&.alive? || false
     end
 
-    # Redraw buffered output into the terminal above/below the current cursor
-    # io - IO object to write to (default $stderr)
+    # Redraw the reserved area using the current buffered lines.
     def redraw(io = $stderr)
       buf = lines
-      _rows, cols = IO.console.winsize
+      debug_log("redraw called; buffer=#{buf.size}; lines=#{@lines}; position=#{@position}")
+
+      # If not streaming live to the terminal, don't redraw during capture.
+      return unless @stream
 
-      # Ensure we have exactly @lines entries (pad with empty strings)
-      display_lines = Array.new(@lines) { '' }
-      start = [0, buf.size - @lines].max
-      buf[start, @lines]&.each_with_index do |l, i|
-        display_lines[i + (@lines - [buf.size, @lines].min)] = l.to_s
+      cols = if defined?(TTY::Screen)
+               TTY::Screen.columns
+             else
+               IO.console.winsize[1]
+             end
+
+      display_lines = Array.new(@lines, '')
+      if buf.empty?
+        # leave display_lines as blanks
+      elsif buf.size <= @lines
+        buf.each_with_index { |l, i| display_lines[i] = l.to_s }
+      else
+        buf.last(@lines).each_with_index { |l, i| display_lines[i] = l.to_s }
       end
 
-      # Save cursor, move up N lines, clear and print buffer, restore cursor
-      io.print "\e[s" # save position
-      io.print "\e[#{@lines}A"            # move up @lines
-      display_lines.each do |line|
-        io.print "\e[2K"                  # clear line
-        io.print "\r"                     # move cursor to start of line
-        io.print line[0, cols]
-        io.print "\n"
+      if defined?(TTY::Cursor)
+        cursor = TTY::Cursor
+        io.print cursor.save
+
+        if @position == :above
+          io.print cursor.up(@lines)
+        else
+          io.print cursor.down(1)
+        end
+
+        display_lines.each_with_index do |line, idx|
+          io.print cursor.clear_line
+          io.print line[0, cols]
+          io.print cursor.down(1) unless idx == display_lines.length - 1
+        end
+
+        io.print cursor.restore
+        debug_log('redraw finished (TTY)')
+      else
+        io.print "\e7"
+
+        if @position == :above
+          io.print "\e[#{@lines}A"
+        else
+          io.print "\e[1B"
+        end
+
+        display_lines.each_with_index do |line, idx|
+          io.print "\e[2K\r"
+          io.print line[0, cols]
+          io.print "\e[1B" unless idx == display_lines.length - 1
+        end
+
+        io.print "\e8"
+        debug_log('redraw finished (ANSI)')
       end
-      io.print "\e[u" # restore
+
       io.flush
+    rescue StandardError => e
+      debug_log("redraw error: #{e.class}: #{e.message}")
+    end
+
+    # Flush the buffered lines to the given IO (defaults to STDOUT).
+    # This is used when capturing non-live output: capture silently during
+    # the run and emit all captured output at the end.
+    def flush_to(io = $stdout)
+      buf = lines
+      return if buf.empty?
+
+      begin
+        buf.each do |line|
+          io.puts(line)
+        end
+        io.flush
+      rescue StandardError => e
+        debug_log("flush_to error: #{e.class}: #{e.message}")
+      end
     end
 
     private
@@ -78,13 +173,16 @@ module RubyProgress
     def spawn_and_read
       PTY.spawn(@command) do |reader, _writer, pid|
         @child_pid = pid
+        debug_log("spawned pid=#{pid} cmd=#{@command}")
+
         until reader.eof? || @stop
           next unless reader.wait_readable(0.1)
 
           chunk = reader.read_nonblock(4096, exception: false)
           next if chunk.nil? || chunk.empty?
 
-          # lazily open log file if requested
+          debug_log("read chunk=#{chunk.inspect}")
+
           if @log_path && !@log_file
             begin
               FileUtils.mkdir_p(File.dirname(@log_path))
@@ -95,29 +193,26 @@ module RubyProgress
           end
 
           process_chunk(chunk)
+          debug_log("after process_chunk buffer_size=#{@buffer.size}")
+
           next unless @log_file
 
           begin
             @log_file.write(chunk)
             @log_file.flush
           rescue StandardError
-            # ignore logging errors
+            # ignore
           end
         end
       end
+
       begin
         Process.wait(@child_pid) if @child_pid
         @exit_status = $CHILD_STATUS.exitstatus if $CHILD_STATUS
       rescue StandardError
         @exit_status = nil
       ensure
-        if @log_file
-          begin
-            @log_file.close
-          rescue StandardError
-            nil
-          end
-        end
+        @log_file&.close
       end
     rescue Errno::EIO
       # PTY finished
@@ -125,12 +220,49 @@ module RubyProgress
 
     def process_chunk(chunk)
       @buf_mutex.synchronize do
-        # split into lines, keep last N lines
         chunk.each_line do |line|
           @buffer << line.chomp
           @buffer.shift while @buffer.size > @lines
         end
       end
+
+      debug_log("process_chunk: buffer=#{@buffer.inspect}")
+      redraw($stderr) if @stream
+    rescue StandardError => e
+      debug_log("process_chunk error: #{e.class}: #{e.message}")
+    end
+
+    def debug_log(msg)
+      return unless ENV['RUBY_PROGRESS_DEBUG'] || @debug
+
+      begin
+        File.open(@debug_path, 'a') do |f|
+          f.puts("#{Time.now.iso8601} PID=#{Process.pid} #{msg}")
+        end
+      rescue StandardError
+        # swallow logging errors
+      end
+    end
+
+    def reserve_space(io = $stderr)
+      return unless io.tty?
+
+      debug_log("reserve_space called; position=#{@position.inspect}; lines=#{@lines}")
+
+      if @position == :above
+        # Insert lines above current cursor using CSI n L
+        io.print "\e[#{@lines}L"
+        debug_log("reserve_space: inserted #{@lines} lines for :above")
+      else
+        # Print newlines then move cursor back up so animation stays above
+        io.print("\n" * @lines)
+        io.print "\e[#{@lines}A"
+        debug_log("reserve_space: printed #{@lines} newlines and moved up #{@lines} for :below")
+      end
+
+      io.flush
+    rescue StandardError => e
+      debug_log("reserve_space error: #{e.class}: #{e.message}")
     end
   end
 end

data/lib/ruby-progress/version.rb

@@ -2,7 +2,7 @@
 
 module RubyProgress
   # Main gem version
-  VERSION = '1.3.2'
+  VERSION = '1.3.4'
 
   # Component-specific versions (patch bumps)
   WORM_VERSION = '1.1.4'

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
@@ -197,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] }