ruby-progress 1.3.2 → 1.3.5

data/lib/ruby-progress/cli/worm_options.rb

@@ -13,7 +13,6 @@ module WormCLI
         output_position: :above,
         output_lines: 3
       }
-      # rubocop:disable Metrics/BlockLength
       begin
         OptionParser.new do |opts|
           opts.banner = 'Usage: prg worm [options]'
@@ -83,6 +82,10 @@ module WormCLI
             options[:stdout] = true
           end
 
+          opts.on('--stdout-live', 'Stream captured output to STDOUT as it arrives (non-blocking)') do
+            options[:stdout_live] = true
+          end
+
           opts.separator ''
           opts.separator 'Daemon Mode:'
 
@@ -101,10 +104,6 @@ module WormCLI
             options[:daemon_name] = name
           end
 
-          opts.on('--no-detach', 'When used with --daemon/--daemon-as: run background child but do not fully detach from the terminal') do
-            options[:no_detach] = true
-          end
-
           opts.on('--pid-file FILE', 'Write process ID to file (default: /tmp/ruby-progress/progress.pid)') do |file|
             options[:pid_file] = file
           end
@@ -178,7 +177,6 @@ module WormCLI
         puts "Run 'prg worm --help' for more information."
         exit 1
       end
-      # rubocop:enable Metrics/BlockLength
       options
     end
   end

data/lib/ruby-progress/cli/worm_runner.rb

@@ -57,11 +57,12 @@ module WormRunner
     stdout_content = nil
 
     begin
-      stdout_content = if $stdout.tty? && @output_stdout
+      stdout_content = if $stdout.tty? && (@output_stdout || @output_live)
                          oc = RubyProgress::OutputCapture.new(
                            command: @command,
                            lines: @output_lines || 3,
-                           position: @output_position || :above
+                           position: @output_position || :above,
+                           stream: @output_live || false
                          )
                          oc.start
                          @output_capture = oc
@@ -69,7 +70,13 @@ module WormRunner
                            oc.wait
                          end
                          @output_capture = nil
-                         oc.lines.join("\n")
+                         # For non-live capture, flush_to handles the output directly
+                         if @output_live
+                           oc.lines.join("\n")
+                         else
+                           oc.flush_to($stdout) if @output_stdout
+                           nil # Don't return content since it's already been flushed
+                         end
                        else
                          animate do
                            Open3.popen3(@command) do |_stdin, stdout, stderr, wait_thr|
@@ -233,8 +240,12 @@ module WormRunner
       $stderr.print "\r\e[2K"
 
       if (frame_count % 10).zero?
-        $stderr.print "\e[1A\e[2K"
-        $stderr.print "\r"
+        # Use ANSI save/restore to clear the previous line without moving the
+        # global cursor position. This prevents the animation from erasing
+        # reserved output lines that we draw elsewhere.
+        $stderr.print "\e7"    # save
+        $stderr.print "\e[1A\e[2K\r"
+        $stderr.print "\e8"    # restore
       end
 
       $stderr.print "#{message_part}#{generate_dots(position, direction)}"

data/lib/ruby-progress/daemon.rb

@@ -4,6 +4,8 @@ require 'json'
 require 'fileutils'
 
 module RubyProgress
+  # Daemon helpers for backgrounding progress indicators.
+  # Provides minimal daemonization, PID file management, and simple control-message signaling.
   module Daemon
     module_function
 
@@ -15,70 +17,6 @@ module RubyProgress
       "#{pid_file}.msg"
     end
 
-    # Resolve a job directory for the daemon based on pid_file or name.
-    # If pid_file is '/tmp/ruby-progress/mytask.pid' -> jobs dir '/tmp/ruby-progress/mytask.jobs'
-    def job_dir_for_pid(pid_file)
-      base = File.basename(pid_file, '.*')
-      File.join(File.dirname(pid_file), "#{base}.jobs")
-    end
-
-    # Process available job files in job_dir. Each job is a JSON file with {"id","command","meta"}.
-    # This method polls the directory and yields each parsed job hash to the provided block.
-    def process_jobs(job_dir, poll_interval: 0.2)
-      FileUtils.mkdir_p(job_dir)
-
-      loop do
-        # Accept any job file ending in .json (UUID filenames are common)
-        # Ignore processed-* archives and temporary files (e.g., .tmp)
-        files = Dir.children(job_dir).select do |f|
-          f.end_with?('.json') && !f.start_with?('processed-')
-        end.sort
-
-        files.each do |f|
-          path = File.join(job_dir, f)
-          processing = "#{path}.processing"
-
-          # Claim the file atomically
-          begin
-            File.rename(path, processing)
-          rescue StandardError
-            next
-          end
-
-          job = begin
-            JSON.parse(File.read(processing))
-          rescue StandardError
-            FileUtils.rm_f(processing)
-            next
-          end
-
-          begin
-            yielded = yield(job)
-
-            # on success, write .result info and merge any returned info
-            result = { 'id' => job['id'], 'status' => 'done', 'time' => Time.now.to_i }
-            if yielded.is_a?(Hash)
-              # ensure string keys
-              extra = yielded.transform_keys(&:to_s)
-              result.merge!(extra)
-            end
-            File.write("#{processing}.result", result.to_json)
-          rescue StandardError => e
-            result = { 'id' => job['id'], 'status' => 'error', 'error' => e.message }
-            File.write("#{processing}.result", result.to_json)
-          ensure
-            begin
-              FileUtils.mv(processing, File.join(job_dir, "processed-#{f}"))
-            rescue StandardError
-              FileUtils.rm_f(processing)
-            end
-          end
-        end
-
-        sleep(poll_interval)
-      end
-    end
-
     def show_status(pid_file)
       if File.exist?(pid_file)
         pid = File.read(pid_file).strip

data/lib/ruby-progress/fill_cli.rb

@@ -58,12 +58,8 @@ module RubyProgress
           pid_file = resolve_pid_file(options, :daemon_name)
           options[:pid_file] = pid_file
 
-          # Detach or background without detaching based on --no-detach
-          if options[:no_detach]
-            PrgCLI.backgroundize
-          else
-            PrgCLI.daemonize
-          end
+          # Background without detaching so progress bar remains visible in current terminal
+          PrgCLI.backgroundize
 
           run_daemon_mode(options, parsed_style)
         elsif options[:current]
@@ -120,71 +116,6 @@ module RubyProgress
         begin
           fill_bar.render # Show initial empty bar
 
-          # Start job processor thread for fill (so daemon can accept jobs)
-          job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
-          Thread.new do
-            RubyProgress::Daemon.process_jobs(job_dir) do |job|
-              jid = job['id'] || SecureRandom.uuid
-              log_path = begin
-                File.join(File.dirname(job_dir), "#{jid}.log")
-              rescue StandardError
-                nil
-              end
-
-              if job['command']
-                oc = RubyProgress::OutputCapture.new(
-                  command: job['command'],
-                  lines: options[:output_lines] || 3,
-                  position: options[:output_position] || :above,
-                  log_path: log_path
-                )
-                oc.start
-
-                fill_bar.instance_variable_set(:@output_capture, oc)
-                oc.wait
-                captured = oc.lines.join("\n")
-                exit_status = oc.exit_status
-                fill_bar.instance_variable_set(:@output_capture, nil)
-
-                success = exit_status.to_i.zero?
-                if job['message']
-                  RubyProgress::Utils.display_completion(
-                    job['message'],
-                    success: success,
-                    show_checkmark: job['checkmark'] || false,
-                    output_stream: :stdout,
-                    icons: { success: options[:success_icon], error: options[:error_icon] }
-                  )
-                end
-
-                { 'exit_status' => exit_status, 'output' => captured, 'log_path' => log_path }
-
-              elsif job['action']
-                case job['action']
-                when 'advance'
-                  fill_bar.advance
-                  { 'status' => 'done', 'action' => 'advance' }
-                when 'percent'
-                  val = job['value'] || job['percent'] || 0
-                  fill_bar.percent = val.to_f
-                  { 'status' => 'done', 'action' => 'percent', 'value' => val }
-                when 'complete'
-                  fill_bar.complete
-                  { 'status' => 'done', 'action' => 'complete' }
-                when 'cancel'
-                  fill_bar.cancel
-                  { 'status' => 'done', 'action' => 'cancel' }
-                else
-                  { 'status' => 'error', 'error' => 'unknown action' }
-                end
-              else
-                { 'status' => 'error', 'error' => 'no command or action provided' }
-              end
-            rescue StandardError
-              nil
-            end
-          end
-
           # Set up signal handlers for daemon control
           stop_requested = false
           Signal.trap('INT') { stop_requested = true }
@@ -298,7 +229,8 @@ module RubyProgress
               command: options[:command],
               lines: options[:output_lines] || 3,
               position: options[:output_position] || :above,
-              log_path: nil
+              log_path: nil,
+              stream: options[:stdout] || options[:stdout_live]
             )
             oc.start
 

data/lib/ruby-progress/output_capture.rb

@@ -3,26 +3,68 @@
 require 'pty'
 require 'io/console'
 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,21 @@ 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)
+          ready = if reader.respond_to?(:wait_readable)
+                    reader.wait_readable(0.1)
+                  else
+                    IO.select([reader], nil, nil, 0.1)
+                  end
+          next unless ready
 
           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 +198,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 +225,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/utils.rb

@@ -41,12 +41,17 @@ module RubyProgress
     def self.display_completion(message, success: true, show_checkmark: false, output_stream: :warn, icons: {})
       return unless message
 
-      mark = if show_checkmark
-               icon = success ? (icons[:success] || '✅') : (icons[:error] || '🛑')
-               "#{icon} "
-             else
-               ''
-             end
+      # Determine the mark to show. If checkmarks are enabled, prefer the
+      # default icons but allow overrides via icons hash. If checkmarks are not
+      # enabled, still show a custom icon when provided via CLI options.
+      mark = ''
+      if show_checkmark
+        icon = success ? (icons[:success] || '✅') : (icons[:error] || '🛑')
+        mark = "#{icon} "
+      else
+        custom_icon = success ? icons[:success] : icons[:error]
+        mark = custom_icon ? "#{custom_icon} " : ''
+      end
 
       formatted_message = "#{mark}#{message}"
 

data/lib/ruby-progress/version.rb

@@ -2,11 +2,11 @@
 
 module RubyProgress
   # Main gem version
-  VERSION = '1.3.2'
+  VERSION = '1.3.5'
 
   # Component-specific versions (patch bumps)
-  WORM_VERSION = '1.1.4'
-  TWIRL_VERSION = '1.1.4'
-  RIPPLE_VERSION = '1.1.4'
-  FILL_VERSION = '1.0.4'
+  WORM_VERSION = '1.1.5'
+  TWIRL_VERSION = '1.1.5'
+  RIPPLE_VERSION = '1.1.5'
+  FILL_VERSION = '1.0.5'
 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
@@ -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] }