ruby-progress 1.1.9 → 1.2.4

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

@@ -0,0 +1,148 @@
+# 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,
+        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('--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,136 @@
+# 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 = {}
+
+      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
+          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

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require_relative 'twirl_spinner'
+
+# Top-level runtime helper module for the Twirl CLI.
+#
+# Contains helper methods used by the `TwirlCLI` dispatcher. These
+# methods implement the runtime behavior (running a command, running
+# indefinitely, or launching in daemon mode) and were extracted to
+# reduce module size and improve testability.
+module TwirlRunner
+  def self.run_with_command(options)
+    message = options[:message]
+    captured_output = nil
+
+    spinner = TwirlSpinner.new(message, options)
+    success = false
+
+    begin
+      RubyProgress::Utils.hide_cursor
+      spinner_thread = Thread.new { loop { spinner.animate } }
+
+      captured_output = `#{options[:command]} 2>&1`
+      success = $CHILD_STATUS.success?
+
+      spinner_thread.kill
+      RubyProgress::Utils.clear_line
+    ensure
+      RubyProgress::Utils.show_cursor
+    end
+
+    puts captured_output if options[:stdout]
+
+    if options[:success] || options[:error] || options[:checkmark]
+      final_msg = success ? options[:success] : options[:error]
+      final_msg ||= success ? 'Success' : 'Failed'
+
+      RubyProgress::Utils.display_completion(
+        final_msg,
+        success: success,
+        show_checkmark: options[:checkmark]
+      )
+    end
+
+    exit success ? 0 : 1
+  end
+
+  def self.run_indefinitely(options)
+    message = options[:message]
+    spinner = TwirlSpinner.new(message, options)
+
+    begin
+      RubyProgress::Utils.hide_cursor
+      loop { spinner.animate }
+    ensure
+      RubyProgress::Utils.show_cursor
+      if options[:success] || options[:checkmark]
+        RubyProgress::Utils.display_completion(
+          options[:success] || 'Complete',
+          success: true,
+          show_checkmark: options[:checkmark]
+        )
+      end
+    end
+  end
+
+  def self.run_daemon_mode(options)
+    pid_file = resolve_pid_file(options, :daemon_name)
+    FileUtils.mkdir_p(File.dirname(pid_file))
+    File.write(pid_file, Process.pid.to_s)
+
+    message = options[:message]
+    spinner = TwirlSpinner.new(message, 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 }
+
+    begin
+      RubyProgress::Utils.hide_cursor
+      spinner.animate until stop_requested
+    ensure
+      RubyProgress::Utils.clear_line
+      RubyProgress::Utils.show_cursor
+
+      # Check for control message
+      cmf = RubyProgress::Daemon.control_message_file(pid_file)
+      if File.exist?(cmf)
+        begin
+          data = JSON.parse(File.read(cmf))
+          message = data['message']
+          check = data.key?('checkmark') ? data['checkmark'] : false
+          success_val = data.key?('success') ? data['success'] : true
+          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
+
+      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
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../utils'
+
+# Minimal spinner implementation used by the Twirl CLI
+#
+# This small class handles animation frame selection and printing
+# for the Twirl command. It was extracted to keep runtime logic
+# out of the CLI dispatcher module.
+class TwirlSpinner
+  def initialize(message, options = {})
+    @message = message
+    @style = parse_style(options[:style] || 'dots')
+    @speed = parse_speed(options[:speed] || 'medium')
+    @frames = RubyProgress::INDICATORS[@style] || RubyProgress::INDICATORS[:dots]
+    @start_chars, @end_chars = RubyProgress::Utils.parse_ends(options[:ends])
+    @index = 0
+  end
+
+  def animate
+    if @message && !@message.empty?
+      $stderr.print "\r\e[2K#{@start_chars}#{@message} #{@frames[@index]}#{@end_chars}"
+    else
+      $stderr.print "\r\e[2K#{@start_chars}#{@frames[@index]}#{@end_chars}"
+    end
+    $stderr.flush
+    @index = (@index + 1) % @frames.length
+    sleep @speed
+  end
+
+  private
+
+  def parse_style(style_input)
+    return :dots unless style_input && !style_input.to_s.strip.empty?
+
+    style_lower = style_input.to_s.downcase.strip
+
+    indicator_keys = RubyProgress::INDICATORS.keys.map(&:to_s)
+    return style_lower.to_sym if indicator_keys.include?(style_lower)
+
+    prefix_matches = indicator_keys.select { |key| key.downcase.start_with?(style_lower) }
+    return prefix_matches.min_by(&:length).to_sym unless prefix_matches.empty?
+
+    fuzzy_matches = indicator_keys.select do |key|
+      key_chars = key.downcase.chars
+      input_chars = style_lower.chars
+      input_chars.all? do |char|
+        idx = key_chars.index(char)
+        if idx
+          key_chars = key_chars[idx + 1..-1]
+          true
+        else
+          false
+        end
+      end
+    end
+
+    return fuzzy_matches.min_by(&:length).to_sym unless fuzzy_matches.empty?
+
+    substring_matches = indicator_keys.select { |key| key.downcase.include?(style_lower) }
+    return substring_matches.min_by(&:length).to_sym unless substring_matches.empty?
+
+    :dots
+  end
+
+  def parse_speed(speed)
+    case speed.to_s.downcase
+    when /^f/, '1', '2', '3'
+      0.05
+    when /^m/, '4', '5', '6', '7'
+      0.1
+    when /^s/, '8', '9', '10'
+      0.2
+    else
+      speed.to_f.positive? ? (1.0 / speed.to_f) : 0.1
+    end
+  end
+end