ruby-progress 1.2.4 → 1.3.2

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}"
@@ -91,7 +95,7 @@ module RubyProgress
     end
 
     # Complete the progress bar and show success message
-    def complete(message = nil)
+    def complete(message = nil, icons: {})
       @current_progress = @length
       render
 
@@ -101,7 +105,8 @@ module RubyProgress
           completion_message,
           success: true,
           show_checkmark: true,
-          output_stream: :warn
+          output_stream: :warn,
+          icons: icons
         )
       else
         $stderr.puts # Just add a newline if no message
@@ -120,7 +125,8 @@ module RubyProgress
         error_msg,
         success: false,
         show_checkmark: true,
-        output_stream: :warn
+        output_stream: :warn,
+        icons: {}
       )
     end
 

data/lib/ruby-progress/fill_cli.rb

@@ -2,10 +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
@@ -34,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
@@ -47,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)
@@ -61,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
@@ -75,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)
@@ -97,6 +120,71 @@ 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 }
@@ -106,51 +194,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,
@@ -163,6 +282,7 @@ module RubyProgress
         fill_bar = Fill.new(fill_options)
         Fill.hide_cursor
 
+        oc = nil
         begin
           if options[:percent]
             # Set to specific percentage
@@ -172,6 +292,34 @@ module RubyProgress
               # For non-complete percentages, show the result briefly
               sleep(0.1)
             end
+          elsif options[:command]
+            # 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
+            )
+            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
+                         when :slow then 0.5
+                         when Numeric then 1.0 / options[:speed]
+                         else 0.3
+                         end
+
+            fill_bar.render
+            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]
@@ -188,10 +336,13 @@ module RubyProgress
               fill_bar.advance
             end
           end
+
           fill_bar.complete
         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
@@ -153,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
 
@@ -161,7 +162,8 @@ module RubyProgress
         display_message,
         success: success,
         show_checkmark: checkmark,
-        output_stream: :warn
+        output_stream: :warn,
+        icons: icons
       )
     end