ruby-progress 1.2.0 → 1.3.1

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'securerandom'
+require_relative 'ripple_options'
+require_relative '../output_capture'
+
+# Enhanced Ripple CLI with unified flags (extracted from bin/prg)
+module RippleCLI
+  def self.run
+    trap('INT') do
+      RubyProgress::Utils.show_cursor
+      exit
+    end
+
+    options = RippleCLI::Options.parse_cli_options
+
+    # Daemon/status/stop handling (process these without requiring text)
+    if options[:status]
+      pid_file = options[:pid_file] || RubyProgress::Daemon.default_pid_file
+      RubyProgress::Daemon.show_status(pid_file)
+      exit
+    elsif options[:stop]
+      pid_file = options[:pid_file] || RubyProgress::Daemon.default_pid_file
+      stop_msg = options[:stop_error] || options[:stop_success]
+      is_error = !options[:stop_error].nil?
+      RubyProgress::Daemon.stop_daemon_by_pid_file(
+        pid_file,
+        message: stop_msg,
+        checkmark: options[:stop_checkmark],
+        error: is_error
+      )
+      exit
+    elsif options[:daemon]
+      # For daemon mode, detach so shell has no tracked job
+      PrgCLI.daemonize
+
+      # For daemon mode, default message if none provided
+      text = options[:message] || ARGV.join(' ')
+      text = 'Processing' if text.nil? || text.empty?
+      run_daemon_mode(text, options)
+    else
+      # Non-daemon path requires text
+      text = options[:message] || ARGV.join(' ')
+      if text.empty?
+        puts 'Error: Please provide text to animate via argument or --message flag'
+        puts "Example: prg ripple 'Loading...' or prg ripple --message 'Loading...'"
+        exit 1
+      end
+
+      # Convert styles array to individual flags for backward compatibility
+      options[:rainbow] = options[:styles].include?(:rainbow)
+      options[:inverse] = options[:styles].include?(:inverse)
+      options[:caps] = options[:styles].include?(:caps)
+
+      if options[:command]
+        run_with_command(text, options)
+      else
+        run_indefinitely(text, options)
+      end
+    end
+  end
+
+  def self.run_with_command(text, options)
+    if $stdout.tty? && options[:output] == :stdout
+      oc = RubyProgress::OutputCapture.new(command: options[:command], lines: options[:output_lines] || 3, position: options[:output_position] || :above)
+      oc.start
+
+      # Create rippler and attach output capture so redraw occurs each frame
+      rippler = RubyProgress::Ripple.new(text, options)
+      rippler.instance_variable_set(:@output_capture, oc)
+
+      thread = Thread.new { loop { rippler.advance } }
+      oc.wait
+      thread.kill
+
+      captured_lines = oc.lines
+      captured_output = captured_lines.join("\n")
+      success = true
+    else
+      # Fallback to legacy capture (non-interactive / CI)
+      captured_output = `#{options[:command]} 2>&1`
+      success = $CHILD_STATUS.success?
+    end
+
+    puts captured_output if options[:output] == :stdout
+    if options[:success_message] || options[:complete_checkmark]
+      message = success ? options[:success_message] : options[:fail_message] || options[:success_message]
+      RubyProgress::Ripple.complete(text, message, options[:complete_checkmark], success)
+    end
+    exit success ? 0 : 1
+  end
+
+  def self.run_indefinitely(text, options)
+    rippler = RubyProgress::Ripple.new(text, options)
+    RubyProgress::Utils.hide_cursor
+    begin
+      loop { rippler.advance }
+    ensure
+      RubyProgress::Utils.show_cursor
+      RubyProgress::Ripple.complete(text, options[:success_message], options[:complete_checkmark], true)
+    end
+  end
+
+  def self.run_daemon_mode(text, options)
+    pid_file = options[:pid_file] || RubyProgress::Daemon.default_pid_file
+    FileUtils.mkdir_p(File.dirname(pid_file))
+    File.write(pid_file, Process.pid.to_s)
+    begin
+      # For Ripple, re-use the existing animation loop via a simple loop
+      RubyProgress::Utils.hide_cursor
+      rippler = RubyProgress::Ripple.new(text, options)
+      stop_requested = false
+
+      Signal.trap('INT') { stop_requested = true }
+      Signal.trap('USR1') { stop_requested = true }
+      Signal.trap('TERM') { stop_requested = true }
+      Signal.trap('HUP')  { stop_requested = true }
+
+      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
+      job_thread = Thread.new { process_daemon_jobs_for_rippler(job_dir, rippler, options) }
+
+      rippler.advance until stop_requested
+    ensure
+      RubyProgress::Utils.clear_line
+      RubyProgress::Utils.show_cursor
+
+      # If a control message file exists, output its message with optional checkmark
+      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
+            )
+          end
+        rescue StandardError
+          # ignore
+        ensure
+          begin
+            File.delete(cmf)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      # stop job thread and cleanup
+      job_thread&.kill
+      FileUtils.rm_f(pid_file)
+    end
+  end
+
+  def self.process_daemon_jobs_for_rippler(job_dir, rippler, options)
+    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
+
+      rippler.instance_variable_set(:@output_capture, oc)
+      oc.wait
+      captured = oc.lines.join("\n")
+      exit_status = oc.exit_status
+      rippler.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; process_jobs will write result
+      nil
+    end
+  end
+
+  # Options parsing moved to ripple_options.rb
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'json'
+
+module RippleCLI
+  # Option parsing extracted to its own file to reduce module size of RippleCLI.
+  module Options
+    def self.parse_cli_options
+      options = {
+        speed: :medium,
+        direction: :bidirectional,
+        styles: [],
+        caps: false,
+        command: nil,
+        success_message: nil,
+        fail_message: nil,
+        complete_checkmark: false,
+        output: :error,
+        output_position: :above,
+        output_lines: 3,
+        message: nil
+      }
+
+      begin
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: prg ripple [options] [STRING]'
+          opts.separator ''
+          opts.separator 'Animation Options:'
+
+          opts.on('-s', '--speed SPEED', 'Animation speed (fast/medium/slow or f/m/s)') do |s|
+            options[:speed] = case s.downcase
+                              when /^f/ then :fast
+                              when /^s/ then :slow
+                              else :medium
+                              end
+          end
+
+          opts.on('-m', '--message MESSAGE', 'Message to display (alternative to positional argument)') do |msg|
+            options[:message] = msg
+          end
+
+          opts.on('--style STYLES', 'Animation styles (rainbow, inverse, caps - can be comma-separated)') do |styles|
+            options[:styles] = styles.split(',').map(&:strip).map(&:to_sym)
+          end
+
+          opts.on('-d', '--direction DIRECTION', 'Animation direction (forward/bidirectional or f/b)') do |f|
+            options[:format] = f =~ /^f/i ? :forward_only : :bidirectional
+          end
+
+          opts.on('--ends CHARS', 'Start/end characters (even number of chars, split in half)') do |chars|
+            options[:ends] = chars
+          end
+
+          opts.separator ''
+          opts.separator 'Command Execution:'
+
+          opts.on('-c', '--command COMMAND', 'Run command during animation (optional)') do |command|
+            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
+
+          opts.on('--error MESSAGE', 'Error message to display') do |msg|
+            options[:fail_message] = msg
+          end
+
+          opts.on('--checkmark', 'Show checkmarks (✅ success, 🛑 failure)') do
+            options[:complete_checkmark] = true
+          end
+
+          opts.on('--stdout', 'Output captured command result to STDOUT') do
+            options[:output] = :stdout
+          end
+
+          opts.on('--quiet', 'Suppress all output') do
+            options[:output] = :quiet
+          end
+
+          opts.separator ''
+          opts.separator 'Daemon Mode:'
+
+          opts.on('--daemon', 'Run in background daemon mode') do
+            options[:daemon] = 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
+
+          opts.on('--stop', 'Stop daemon (uses default PID file unless --pid-file specified)') do
+            options[:stop] = true
+          end
+
+          opts.on('--status', 'Show daemon status (running/not running)') do
+            options[:status] = true
+          end
+
+          opts.on('--stop-success MESSAGE', 'When stopping, show this success message') do |msg|
+            options[:stop_success] = msg
+          end
+          opts.on('--stop-error MESSAGE', 'When stopping, show this error message') do |msg|
+            options[:stop_error] = msg
+          end
+          opts.on('--stop-checkmark', 'When stopping, include a success/error checkmark') do
+            options[:stop_checkmark] = true
+          end
+
+          opts.separator ''
+          opts.separator 'Daemon notes:'
+          opts.separator '  - Do not append &; prg detaches itself and returns immediately.'
+          opts.separator '  - Use --status/--stop with optional --pid-file to control it.'
+
+          opts.separator ''
+          opts.separator 'General:'
+
+          opts.on('--show-styles', 'Show available ripple styles with visual previews') do
+            PrgCLI.show_ripple_styles
+            exit
+          end
+
+          opts.on('--stop-all', 'Stop all prg ripple processes') do
+            success = PrgCLI.stop_subcommand_processes('ripple')
+            exit(success ? 0 : 1)
+          end
+
+          opts.on('-v', '--version', 'Show version') do
+            puts "Ripple version #{RubyProgress::VERSION}"
+            exit
+          end
+
+          opts.on('-h', '--help', 'Show this help') do
+            puts opts
+            exit
+          end
+        end.parse!
+      rescue OptionParser::InvalidOption => e
+        puts "Invalid option: #{e.args.first}"
+        puts ''
+        puts 'Usage: prg ripple [options] [STRING]'
+        puts "Run 'prg ripple --help' for more information."
+        exit 1
+      end
+
+      options
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'twirl_options'
+require_relative 'twirl_spinner'
+require_relative 'twirl_runner'
+
+# Twirl CLI (extracted from bin/prg)
+module TwirlCLI
+  def self.run
+    options = TwirlCLI::Options.parse_cli_options
+
+    if options[:status]
+      pid_file = resolve_pid_file(options, :status_name)
+      RubyProgress::Daemon.show_status(pid_file)
+      exit
+    elsif options[:stop]
+      pid_file = resolve_pid_file(options, :stop_name)
+      stop_msg = options[:stop_error] || options[:stop_success]
+      is_error = !options[:stop_error].nil?
+      RubyProgress::Daemon.stop_daemon_by_pid_file(
+        pid_file,
+        message: stop_msg,
+        checkmark: options[:stop_checkmark],
+        error: is_error
+      )
+      exit
+    elsif options[:daemon]
+      PrgCLI.daemonize
+      TwirlRunner.run_daemon_mode(options)
+    elsif options[:command]
+      TwirlRunner.run_with_command(options)
+    else
+      TwirlRunner.run_indefinitely(options)
+    end
+  end
+
+  # runtime methods moved to TwirlRunner
+  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
+
+  def self.parse_cli_options
+    options = {}
+
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: prg twirl [options]'
+      opts.separator ''
+      opts.separator 'Animation Options:'
+
+      opts.on('-s', '--speed SPEED', 'Animation speed (1-10, fast/medium/slow, or f/m/s)') do |speed|
+        options[:speed] = speed
+      end
+
+      opts.on('-m', '--message MESSAGE', 'Message to display before spinner') do |message|
+        options[:message] = message
+      end
+
+      opts.on('--style STYLE', 'Spinner style (see --show-styles for options)') do |style|
+        options[:style] = style
+      end
+
+      opts.on('--ends CHARS', 'Start/end characters (even number of chars, split in half)') do |chars|
+        options[:ends] = chars
+      end
+
+      opts.separator ''
+      opts.separator 'Command Execution:'
+
+      opts.on('-c', '--command COMMAND', 'Command to run (optional - runs indefinitely without)') do |command|
+        options[:command] = command
+      end
+
+      opts.on('--success MESSAGE', 'Success message to display') do |text|
+        options[:success] = text
+      end
+
+      opts.on('--error MESSAGE', 'Error message to display') do |text|
+        options[:error] = text
+      end
+
+      opts.on('--checkmark', 'Show checkmarks (✅ success, 🛑 failure)') do
+        options[:checkmark] = true
+      end
+
+      opts.on('--stdout', 'Output captured command result to STDOUT') do |_text|
+        options[:stdout] = true
+      end
+
+      opts.separator ''
+      opts.separator 'Daemon Mode:'
+
+      opts.on('--daemon', 'Run in background daemon mode') do
+        options[:daemon] = true
+      end
+
+      opts.on('--daemon-as NAME', 'Run in daemon mode with custom name (creates /tmp/ruby-progress/NAME.pid)') 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
+
+      opts.on('--stop', 'Stop daemon (uses default PID file unless --pid-file specified)') do
+        options[:stop] = true
+      end
+      opts.on('--stop-id NAME', 'Stop daemon by name (automatically implies --stop)') do |name|
+        options[:stop] = true
+        options[:stop_name] = name
+      end
+      opts.on('--status', 'Show daemon status (uses default PID file unless --pid-file specified)') do
+        options[:status] = true
+      end
+      opts.on('--status-id NAME', 'Show daemon status by name') do |name|
+        options[:status] = true
+        options[:status_name] = name
+      end
+      opts.on('--stop-success MESSAGE', 'Stop daemon with success message (automatically implies --stop)') do |msg|
+        options[:stop] = true
+        options[:stop_success] = msg
+      end
+      opts.on('--stop-error MESSAGE', 'Stop daemon with error message (automatically implies --stop)') do |msg|
+        options[:stop] = true
+        options[:stop_error] = msg
+      end
+      opts.on('--stop-checkmark', 'When stopping, include a success checkmark') { options[:stop_checkmark] = true }
+
+      opts.separator ''
+      opts.separator 'Daemon notes:'
+      opts.separator '  - Do not append &; prg detaches itself and returns immediately.'
+      opts.separator '  - Use --daemon-as NAME for named daemons, or --stop-id/--status-id for named control.'
+
+      opts.separator ''
+      opts.separator 'General:'
+
+      opts.on('--show-styles', 'Show available twirl styles with visual previews') do
+        PrgCLI.show_twirl_styles
+        exit
+      end
+
+      opts.on('--stop-all', 'Stop all prg twirl processes') do
+        success = PrgCLI.stop_subcommand_processes('twirl')
+        exit(success ? 0 : 1)
+      end
+
+      opts.on('-v', '--version', 'Show version') do
+        puts "Twirl version #{RubyProgress::VERSION}"
+        exit
+      end
+
+      opts.on('-h', '--help', 'Show this help') do
+        puts opts
+        exit
+      end
+    end.parse!
+
+    options
+  rescue OptionParser::InvalidOption => e
+    puts "Invalid option: #{e.args.first}"
+    puts ''
+    puts 'Usage: prg twirl [options]'
+    puts "Run 'prg twirl --help' for more information."
+    exit 1
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'json'
+
+module TwirlCLI
+  # Option parsing helpers for the Twirl subcommand.
+  #
+  # Keeps the CLI option definitions extracted from the main dispatcher
+  # so the `TwirlCLI` module stays small and focused on dispatching.
+  module Options
+    def self.parse_cli_options
+      options = {
+        output_position: :above,
+        output_lines: 3
+      }
+
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: prg twirl [options]'
+        opts.separator ''
+        opts.separator 'Animation Options:'
+
+        opts.on('-s', '--speed SPEED', 'Animation speed (1-10, fast/medium/slow, or f/m/s)') do |speed|
+          options[:speed] = speed
+        end
+
+        opts.on('-m', '--message MESSAGE', 'Message to display before spinner') do |message|
+          options[:message] = message
+        end
+
+        opts.on('--style STYLE', 'Spinner style (see --show-styles for options)') do |style|
+          options[:style] = style
+        end
+
+        opts.on('--ends CHARS', 'Start/end characters (even number of chars, split in half)') do |chars|
+          options[:ends] = chars
+        end
+
+        opts.separator ''
+        opts.separator 'Command Execution:'
+
+        opts.on('-c', '--command COMMAND', 'Command to run (optional - runs indefinitely without)') do |command|
+          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
+
+        opts.on('--error MESSAGE', 'Error message to display') do |text|
+          options[:error] = text
+        end
+
+        opts.on('--checkmark', 'Show checkmarks (✅ success, 🛑 failure)') do
+          options[:checkmark] = true
+        end
+
+        opts.on('--stdout', 'Output captured command result to STDOUT') do
+          options[:stdout] = true
+        end
+
+        opts.separator ''
+        opts.separator 'Daemon Mode:'
+
+        opts.on('--daemon', 'Run in background daemon mode') do
+          options[:daemon] = true
+        end
+
+        opts.on('--daemon-as NAME', 'Run in daemon mode with custom name (creates /tmp/ruby-progress/NAME.pid)') 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
+
+        opts.on('--stop', 'Stop daemon (uses default PID file unless --pid-file specified)') do
+          options[:stop] = true
+        end
+        opts.on('--stop-id NAME', 'Stop daemon by name (automatically implies --stop)') do |name|
+          options[:stop] = true
+          options[:stop_name] = name
+        end
+        opts.on('--status', 'Show daemon status (uses default PID file unless --pid-file specified)') do
+          options[:status] = true
+        end
+        opts.on('--status-id NAME', 'Show daemon status by name') do |name|
+          options[:status] = true
+          options[:status_name] = name
+        end
+        opts.on('--stop-success MESSAGE', 'Stop daemon with success message (automatically implies --stop)') do |msg|
+          options[:stop] = true
+          options[:stop_success] = msg
+        end
+        opts.on('--stop-error MESSAGE', 'Stop daemon with error message (automatically implies --stop)') do |msg|
+          options[:stop] = true
+          options[:stop_error] = msg
+        end
+        opts.on('--stop-checkmark', 'When stopping, include a success checkmark') { options[:stop_checkmark] = true }
+
+        opts.separator ''
+        opts.separator 'Daemon notes:'
+        opts.separator '  - Do not append &; prg detaches itself and returns immediately.'
+        opts.separator '  - Use --daemon-as NAME for named daemons, or --stop-id/--status-id for named control.'
+
+        opts.separator ''
+        opts.separator 'General:'
+
+        opts.on('--show-styles', 'Show available twirl styles with visual previews') do
+          PrgCLI.show_twirl_styles
+          exit
+        end
+
+        opts.on('--stop-all', 'Stop all prg twirl processes') do
+          success = PrgCLI.stop_subcommand_processes('twirl')
+          exit(success ? 0 : 1)
+        end
+
+        opts.on('-v', '--version', 'Show version') do
+          puts "Twirl version #{RubyProgress::VERSION}"
+          exit
+        end
+
+        opts.on('-h', '--help', 'Show this help') do
+          puts opts
+          exit
+        end
+      end.parse!
+      options
+    rescue OptionParser::InvalidOption => e
+      puts "Invalid option: #{e.args.first}"
+      puts ''
+      puts 'Usage: prg twirl [options]'
+      puts "Run 'prg twirl --help' for more information."
+      exit 1
+    end
+  end
+end