ruby-progress 1.3.1 → 1.3.4

data/lib/ruby-progress/fill_cli.rb

@@ -2,11 +2,14 @@
 
 require 'optparse'
 require 'fileutils'
+require 'json'
+require 'securerandom'
 require_relative 'cli/fill_options'
 require_relative 'output_capture'
 
 module RubyProgress
   # CLI module for Fill command
+  # rubocop:disable Metrics/ClassLength
   module FillCLI
     class << self
       def run
@@ -35,11 +38,14 @@ module RubyProgress
 
         # Handle daemon control first
         if options[:status] || options[:stop]
-          pid_file = options[:pid_file] || '/tmp/ruby-progress/fill.pid'
+          pid_file = resolve_pid_file(options, :status_name)
           if options[:status]
             Daemon.show_status(pid_file)
           else
-            Daemon.stop_daemon_by_pid_file(pid_file)
+            Daemon.stop_daemon_by_pid_file(pid_file,
+                                           message: options[:stop_success],
+                                           checkmark: options[:stop_checkmark],
+                                           error: !options[:stop_error].nil?)
           end
           exit
         end
@@ -48,6 +54,17 @@ module RubyProgress
         parsed_style = parse_fill_style(options[:style])
 
         if options[:daemon]
+          # Resolve pid file and honor daemon-as/name
+          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
+
           run_daemon_mode(options, parsed_style)
         elsif options[:current]
           show_current_percentage(options, parsed_style)
@@ -62,6 +79,14 @@ module RubyProgress
 
       private
 
+      def 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]
+
+        '/tmp/ruby-progress/fill.pid'
+      end
+
       def parse_fill_style(style_option)
         case style_option
         when String
@@ -76,9 +101,6 @@ module RubyProgress
       end
 
       def run_daemon_mode(options, parsed_style)
-        # For daemon mode, detach the process
-        PrgCLI.daemonize
-
         pid_file = options[:pid_file] || '/tmp/ruby-progress/fill.pid'
         FileUtils.mkdir_p(File.dirname(pid_file))
         File.write(pid_file, Process.pid.to_s)
@@ -98,6 +120,72 @@ 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,
+                  stream: options[:stdout_live]
+                )
+                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 }
@@ -107,51 +195,82 @@ module RubyProgress
           # Keep daemon alive until stop requested
           sleep(0.1) until stop_requested
         ensure
+          # If a control message file exists, print its contents like other CLIs
+          cmf = RubyProgress::Daemon.control_message_file(pid_file)
+          if File.exist?(cmf)
+            begin
+              data = JSON.parse(File.read(cmf))
+              message = data['message']
+              check = if data.key?('checkmark')
+                        data['checkmark'] ? true : false
+                      else
+                        false
+                      end
+
+              success_val = if data.key?('success')
+                              data['success'] ? true : false
+                            else
+                              true
+                            end
+              if message
+                RubyProgress::Utils.display_completion(
+                  message,
+                  success: success_val,
+                  show_checkmark: check,
+                  output_stream: :stdout,
+                  icons: { success: options[:success_icon], error: options[:error_icon] }
+                )
+              end
+            rescue StandardError
+              # ignore
+            ensure
+              begin
+                File.delete(cmf)
+              rescue StandardError
+                nil
+              end
+            end
+          end
+
           Fill.show_cursor
           FileUtils.rm_f(pid_file)
         end
       end
 
-      def show_current_percentage(options, _parsed_style)
-        # Just output the percentage for scripting (default to 50% for demonstration)
-        percentage = options[:percent] || 50
-        puts percentage.to_f
-      end
-
       def show_progress_report(options, parsed_style)
-        # Create a fill bar to demonstrate current progress
-        fill_options = {
-          style: parsed_style,
-          length: options[:length],
-          ends: options[:ends]
-        }
-
-        fill_bar = Fill.new(fill_options)
-
-        # Set percentage (default to 50% for demonstration)
-        fill_bar.percent = options[:percent] || 50
-
-        # Get detailed report
-        report = fill_bar.report
-
-        # Display the current progress bar and detailed status
-        fill_bar.render
-        puts "\nProgress Report:"
-        puts "  Progress: #{report[:progress][0]}/#{report[:progress][1]}"
-        puts "  Percent: #{report[:percent]}%"
-        puts "  Completed: #{report[:completed] ? 'Yes' : 'No'}"
-        puts "  Style: #{report[:style]}"
+        # Produce a simple scripting-friendly report to stdout
+        length = options[:length] || 20
+        percent = (options[:percent] || 50.0).to_f
+        style = parsed_style
+
+        fill = Fill.new(style: style, length: length)
+        fill.percent = percent
+
+        report = fill.report
+        puts 'Progress Report:'
+        puts "Progress: #{report[:progress][0]}/#{report[:progress][1]}"
+        puts "Percent: #{report[:percent]}%"
+        puts "Completed: #{report[:completed] ? 'Yes' : 'No'}"
+        puts "Style: #{report[:style].inspect}"
+        exit(0)
       end
 
       def handle_progress_commands(_options, _parsed_style)
-        # For progress commands, we assume there's a daemon running
-        # This is a simplified version - in a real implementation,
-        # we'd need IPC to communicate with the daemon
+        # For now the progress commands are only supported in daemon mode.
+        # Return a clear error to the caller (specs assert this message exists).
         warn 'Progress commands require daemon mode implementation'
-        warn "Run 'prg fill --daemon' first, then use progress commands"
-        exit 1
+        exit(1)
+      end
+
+      def show_current_percentage(options, _parsed_style)
+        # For scripting and tests: print the current percentage to stdout and exit.
+        # If no explicit percent was provided, default to 50.0
+        percent = (options[:percent] || 50.0).to_f
+        $stdout.print("#{percent}\n")
+        exit(0)
       end
 
+      # Foreground / auto-advance / command mode when not daemonizing
       def run_auto_advance_mode(options, parsed_style)
         fill_options = {
           style: parsed_style,
@@ -161,20 +280,10 @@ 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
 
+        oc = nil
         begin
           if options[:percent]
             # Set to specific percentage
@@ -185,7 +294,20 @@ module RubyProgress
               sleep(0.1)
             end
           elsif options[:command]
-            # While the command runs, keep redrawing the bar (live redraw handled by Fill#render)
+            # Run the command with OutputCapture
+            oc = RubyProgress::OutputCapture.new(
+              command: options[:command],
+              lines: options[:output_lines] || 3,
+              position: options[:output_position] || :above,
+              log_path: nil,
+              stream: options[:stdout] || options[:stdout_live]
+            )
+            oc.start
+
+            # Attach capture to the live fill instance so it can render output
+            fill_bar.instance_variable_set(:@output_capture, oc)
+
+            # While the command runs, keep redrawing the bar
             sleep_time = case options[:speed]
                          when :fast then 0.1
                          when :medium, nil then 0.2
@@ -195,11 +317,11 @@ module RubyProgress
                          end
 
             fill_bar.render
-            # Loop until the OutputCapture reader has finished
             while oc.alive?
               sleep(sleep_time)
               fill_bar.render
             end
+            fill_bar.instance_variable_set(:@output_capture, nil)
           else
             # Auto-advance mode
             sleep_time = case options[:speed]
@@ -216,6 +338,7 @@ module RubyProgress
               fill_bar.advance
             end
           end
+
           fill_bar.complete
         rescue Interrupt
           fill_bar.cancel

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/ripple.rb

@@ -154,7 +154,7 @@ module RubyProgress
       RubyProgress::Utils.show_cursor
     end
 
-    def self.complete(string, message, checkmark, success)
+    def self.complete(string, message, checkmark, success, icons: {})
       display_message = message || (checkmark ? string : nil)
       return unless display_message
 
@@ -162,7 +162,8 @@ module RubyProgress
         display_message,
         success: success,
         show_checkmark: checkmark,
-        output_stream: :warn
+        output_stream: :warn,
+        icons: icons
       )
     end