ruby-progress 1.2.4 → 1.3.1

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

@@ -17,6 +17,8 @@ module RippleCLI
         fail_message: nil,
         complete_checkmark: false,
         output: :error,
+        output_position: :above,
+        output_lines: 3,
         message: nil
       }
 
@@ -57,6 +59,14 @@ module RippleCLI
             options[:command] = command
           end
 
+          opts.on('--output-position POSITION', 'Position to render captured output: above or below (default: above)') do |pos|
+            options[:output_position] = pos.to_sym
+          end
+
+          opts.on('--output-lines N', Integer, 'Number of output lines to reserve for captured output (default: 3)') do |n|
+            options[:output_lines] = n
+          end
+
           opts.on('--success MESSAGE', 'Success message to display') do |msg|
             options[:success_message] = msg
           end

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

@@ -10,7 +10,10 @@ module TwirlCLI
   # so the `TwirlCLI` module stays small and focused on dispatching.
   module Options
     def self.parse_cli_options
-      options = {}
+      options = {
+        output_position: :above,
+        output_lines: 3
+      }
 
       OptionParser.new do |opts|
         opts.banner = 'Usage: prg twirl [options]'
@@ -40,6 +43,14 @@ module TwirlCLI
           options[:command] = command
         end
 
+        opts.on('--output-position POSITION', 'Position to render captured output: above or below (default: above)') do |pos|
+          options[:output_position] = pos.to_sym
+        end
+
+        opts.on('--output-lines N', Integer, 'Number of output lines to reserve for captured output (default: 3)') do |n|
+          options[:output_lines] = n
+        end
+
         opts.on('--success MESSAGE', 'Success message to display') do |text|
           options[:success] = text
         end

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

@@ -3,6 +3,7 @@
 require 'fileutils'
 require 'json'
 require_relative 'twirl_spinner'
+require_relative '../output_capture'
 
 # Top-level runtime helper module for the Twirl CLI.
 #
@@ -22,8 +23,25 @@ module TwirlRunner
       RubyProgress::Utils.hide_cursor
       spinner_thread = Thread.new { loop { spinner.animate } }
 
-      captured_output = `#{options[:command]} 2>&1`
-      success = $CHILD_STATUS.success?
+      if $stdout.tty? && options[:stdout]
+        oc = RubyProgress::OutputCapture.new(
+          command: options[:command],
+          lines: options[:output_lines] || 3,
+          position: options[:output_position] || :above
+        )
+        oc.start
+
+        spinner.instance_variable_set(:@output_capture, oc)
+
+        # wait for command while spinner thread runs
+        oc.wait
+        captured_lines = oc.lines
+        captured_output = captured_lines.join("\n")
+        success = true
+      else
+        captured_output = `#{options[:command]} 2>&1`
+        success = $CHILD_STATUS.success?
+      end
 
       spinner_thread.kill
       RubyProgress::Utils.clear_line
@@ -82,6 +100,40 @@ module TwirlRunner
 
     begin
       RubyProgress::Utils.hide_cursor
+
+      # Start job processor thread for twirl
+      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
+      job_thread = Thread.new do
+        RubyProgress::Daemon.process_jobs(job_dir) do |job|
+          oc = RubyProgress::OutputCapture.new(
+            command: job['command'],
+            lines: options[:output_lines] || 3,
+            position: options[:output_position] || :above
+          )
+          oc.start
+
+          spinner.instance_variable_set(:@output_capture, oc)
+          oc.wait
+          captured = oc.lines.join("\n")
+          exit_status = oc.exit_status
+          spinner.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
+            )
+          end
+
+          { 'exit_status' => exit_status, 'output' => captured }
+        rescue StandardError
+          # ignore
+        end
+      end
+
       spinner.animate until stop_requested
     ensure
       RubyProgress::Utils.clear_line
@@ -114,6 +166,7 @@ module TwirlRunner
         end
       end
 
+      job_thread&.kill
       FileUtils.rm_f(pid_file)
     end
   end

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

@@ -18,6 +18,7 @@ class TwirlSpinner
   end
 
   def animate
+    @output_capture&.redraw($stderr)
     if @message && !@message.empty?
       $stderr.print "\r\e[2K#{@start_chars}#{@message} #{@frames[@index]}#{@end_chars}"
     else

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

@@ -6,6 +6,14 @@ require_relative 'worm_options'
 
 # Enhanced Worm CLI (extracted from bin/prg)
 module WormCLI
+  def self.resolve_pid_file(options, name_key = :daemon_name)
+    return options[:pid_file] if options[:pid_file]
+
+    return "/tmp/ruby-progress/#{options[name_key]}.pid" if options[name_key]
+
+    RubyProgress::Daemon.default_pid_file
+  end
+
   def self.run
     options = WormCLI::Options.parse_cli_options
 
@@ -47,29 +55,55 @@ module WormCLI
     progress = RubyProgress::Worm.new(options)
 
     begin
+      # Start job processor thread for worm
+      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
+      job_thread = 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
+
+          oc = RubyProgress::OutputCapture.new(
+            command: job['command'],
+            lines: options[:output_lines] || 3,
+            position: options[:output_position] || :above,
+            log_path: log_path
+          )
+          oc.start
+
+          progress.instance_variable_set(:@output_capture, oc)
+          oc.wait
+          captured = oc.lines.join("\n")
+          exit_status = oc.exit_status
+          progress.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
+            )
+          end
+
+          { 'exit_status' => exit_status, 'output' => captured, 'log_path' => log_path }
+        rescue StandardError
+          # ignore per-job errors
+        end
+      end
+
       progress.run_daemon_mode(
         success_message: options[:success],
         show_checkmark: options[:checkmark],
         control_message_file: RubyProgress::Daemon.control_message_file(pid_file)
       )
     ensure
+      job_thread&.kill
       FileUtils.rm_f(pid_file)
     end
   end
-
-  def self.resolve_pid_file(options, name_key)
-    return options[:pid_file] if options[:pid_file]
-
-    if options[name_key]
-      "/tmp/ruby-progress/#{options[name_key]}.pid"
-    else
-      RubyProgress::Daemon.default_pid_file
-    end
-  end
-
-  # parse_cli_options is intentionally kept together; further extraction possible
-  # parse_cli_options is intentionally delegated to WormCLI::Options
-  def self.parse_cli_options
-    WormCLI::Options.parse_cli_options
-  end
 end

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

@@ -9,8 +9,11 @@ module WormCLI
   # the main dispatcher to keep the CLI module small and focused.
   module Options
     def self.parse_cli_options
-      options = {}
-
+      options = {
+        output_position: :above,
+        output_lines: 3
+      }
+      # rubocop:disable Metrics/BlockLength
       begin
         OptionParser.new do |opts|
           opts.banner = 'Usage: prg worm [options]'
@@ -48,6 +51,14 @@ module WormCLI
             options[:command] = command
           end
 
+          opts.on('--output-position POSITION', 'Position to render captured output: above or below (default: above)') do |pos|
+            options[:output_position] = pos.to_sym
+          end
+
+          opts.on('--output-lines N', Integer, 'Number of output lines to reserve for captured output (default: 3)') do |n|
+            options[:output_lines] = n
+          end
+
           opts.on('--success MESSAGE', 'Success message to display') do |text|
             options[:success] = text
           end
@@ -76,6 +87,12 @@ module WormCLI
             options[:daemon_name] = name
           end
 
+          # Accept --daemon-name as an alias for --daemon-as for compatibility
+          opts.on('--daemon-name NAME', 'Alias for --daemon-as (compat)') do |name|
+            options[:daemon] = true
+            options[:daemon_name] = name
+          end
+
           opts.on('--pid-file FILE', 'Write process ID to file (default: /tmp/ruby-progress/progress.pid)') do |file|
             options[:pid_file] = file
           end
@@ -149,7 +166,7 @@ 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

@@ -1,9 +1,11 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ModuleLength
 require 'open3'
 require 'json'
 require_relative '../utils'
+require_relative '../output_capture'
 
 # Runtime helper methods for RubyProgress::Worm
 #
@@ -56,21 +58,36 @@ module WormRunner
     stdout_content = nil
 
     begin
-      stdout_content = animate do
-        Open3.popen3(@command) do |_stdin, stdout, stderr, wait_thr|
-          captured_stdout = stdout.read
-          stderr_content = stderr.read
-          exit_code = wait_thr.value.exitstatus
-
-          unless wait_thr.value.success?
-            error_msg = @error_text || "Command failed with exit code #{exit_code}"
-            error_msg += ": #{stderr_content.strip}" if stderr_content && !stderr_content.empty?
-            raise StandardError, error_msg
-          end
-
-          captured_stdout
-        end
-      end
+      stdout_content = if $stdout.tty? && @output_stdout
+                         oc = RubyProgress::OutputCapture.new(
+                           command: @command,
+                           lines: @output_lines || 3,
+                           position: @output_position || :above
+                         )
+                         oc.start
+                         @output_capture = oc
+                         animate do
+                           oc.wait
+                         end
+                         @output_capture = nil
+                         oc.lines.join("\n")
+                       else
+                         animate do
+                           Open3.popen3(@command) do |_stdin, stdout, stderr, wait_thr|
+                             captured_stdout = stdout.read
+                             stderr_content = stderr.read
+                             exit_code = wait_thr.value.exitstatus
+
+                             unless wait_thr.value.success?
+                               error_msg = @error_text || "Command failed with exit code #{exit_code}"
+                               error_msg += ": #{stderr_content.strip}" if stderr_content && !stderr_content.empty?
+                               raise StandardError, error_msg
+                             end
+
+                             captured_stdout
+                           end
+                         end
+                       end
 
       puts stdout_content if @output_stdout && stdout_content
     rescue StandardError
@@ -161,6 +178,7 @@ module WormRunner
     @direction ||= 1
 
     message_part = @message && !@message.empty? ? "#{@message} " : ''
+    @output_capture&.redraw($stderr)
     $stderr.print "\r\e[2K#{@start_chars}#{message_part}#{generate_dots(@position, @direction)}#{@end_chars}"
     $stderr.flush
 
@@ -184,6 +202,7 @@ module WormRunner
 
     while @running
       message_part = @message && !@message.empty? ? "#{@message} " : ''
+      @output_capture&.redraw($stderr)
       $stderr.print "\r\e[2K#{@start_chars}#{message_part}#{generate_dots(position, direction)}#{@end_chars}"
       $stderr.flush
 
@@ -209,6 +228,7 @@ module WormRunner
 
     while @running && !stop_requested_proc.call
       message_part = @message && !@message.empty? ? "#{@message} " : ''
+      @output_capture&.redraw($stderr)
 
       $stderr.print "\r\e[2K"
 
@@ -258,3 +278,5 @@ module WormRunner
     dots.join
   end
 end
+
+# rubocop:enable Metrics/ModuleLength

data/lib/ruby-progress/daemon.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'fileutils'
 
 module RubyProgress
   module Daemon
@@ -14,6 +15,70 @@ 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.rb

@@ -25,6 +25,7 @@ module RubyProgress
       @current_progress = 0
       @success_message = options[:success]
       @error_message = options[:error]
+      @output_capture = options[:output_capture]
 
       # Parse --ends characters
       if options[:ends]
@@ -82,6 +83,9 @@ module RubyProgress
 
     # Render the current progress bar to stderr
     def render
+      # First redraw captured output (if any) so it appears above/below the bar
+      @output_capture&.redraw($stderr)
+
       filled = @style[:full] * @current_progress
       empty = @style[:empty] * (@length - @current_progress)
       bar = "#{@start_chars}#{filled}#{empty}#{@end_chars}"

data/lib/ruby-progress/fill_cli.rb

@@ -3,6 +3,7 @@
 require 'optparse'
 require 'fileutils'
 require_relative 'cli/fill_options'
+require_relative 'output_capture'
 
 module RubyProgress
   # CLI module for Fill command
@@ -160,6 +161,17 @@ module RubyProgress
           error: options[:error_message]
         }
 
+        # If a command is provided, capture its output and pass an OutputCapture
+        if options[:command]
+          oc = RubyProgress::OutputCapture.new(
+            command: options[:command],
+            lines: options[:output_lines] || 3,
+            position: options[:output_position] || :above
+          )
+          oc.start
+          fill_options[:output_capture] = oc
+        end
+
         fill_bar = Fill.new(fill_options)
         Fill.hide_cursor
 
@@ -172,6 +184,22 @@ module RubyProgress
               # For non-complete percentages, show the result briefly
               sleep(0.1)
             end
+          elsif options[:command]
+            # While the command runs, keep redrawing the bar (live redraw handled by Fill#render)
+            sleep_time = case options[:speed]
+                         when :fast then 0.1
+                         when :medium, nil then 0.2
+                         when :slow then 0.5
+                         when Numeric then 1.0 / options[:speed]
+                         else 0.3
+                         end
+
+            fill_bar.render
+            # Loop until the OutputCapture reader has finished
+            while oc.alive?
+              sleep(sleep_time)
+              fill_bar.render
+            end
           else
             # Auto-advance mode
             sleep_time = case options[:speed]
@@ -192,6 +220,8 @@ module RubyProgress
         rescue Interrupt
           fill_bar.cancel
         ensure
+          # Ensure we wait for capture thread to finish and show cursor
+          oc&.wait
           Fill.show_cursor
         end
       end

data/lib/ruby-progress/output_capture.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'io/console'
+require 'English'
+
+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.
+  class OutputCapture
+    attr_reader :exit_status
+
+    def initialize(command:, lines: 3, position: :above, log_path: nil)
+      @command = command
+      @lines = lines
+      @position = position
+      @buffer = []
+      @buf_mutex = Mutex.new
+      @stop = false
+      @log_path = log_path
+      @log_file = nil
+    end
+
+    # Start the child process and return a thread that manages capture.
+    def start
+      @reader_thread = Thread.new { spawn_and_read }
+      self
+    end
+
+    def stop
+      @stop = true
+      @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)
+    def redraw(io = $stderr)
+      buf = lines
+      _rows, cols = IO.console.winsize
+
+      # 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
+      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"
+      end
+      io.print "\e[u" # restore
+      io.flush
+    end
+
+    private
+
+    def spawn_and_read
+      PTY.spawn(@command) do |reader, _writer, pid|
+        @child_pid = pid
+        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
+          if @log_path && !@log_file
+            begin
+              FileUtils.mkdir_p(File.dirname(@log_path))
+              @log_file = File.open(@log_path, 'a')
+            rescue StandardError
+              @log_file = nil
+            end
+          end
+
+          process_chunk(chunk)
+          next unless @log_file
+
+          begin
+            @log_file.write(chunk)
+            @log_file.flush
+          rescue StandardError
+            # ignore logging errors
+          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
+      end
+    rescue Errno::EIO
+      # PTY finished
+    end
+
+    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
+    end
+  end
+end

data/lib/ruby-progress/ripple.rb

@@ -140,6 +140,7 @@ module RubyProgress
         char = @rainbow ? char.rainbow(i) : char.extend(StringExtensions).light_white
         post = letters.slice!(0, letters.length).join.extend(StringExtensions).dark_white
       end
+      @output_capture&.redraw($stderr)
       $stderr.print "\r\e[2K#{@start_chars}#{pre}#{char}#{post}#{@end_chars}"
       $stderr.flush
     end

data/lib/ruby-progress/version.rb

@@ -2,11 +2,11 @@
 
 module RubyProgress
   # Main gem version
-  VERSION = '1.2.4'
+  VERSION = '1.3.1'
 
-  # Component-specific versions
-  WORM_VERSION = '1.1.2'
-  TWIRL_VERSION = '1.1.2'
-  RIPPLE_VERSION = '1.1.2'
-  FILL_VERSION = '1.0.1'
+  # 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'
 end