ruby-progress 1.1.3 → 1.1.8

data/bin/prg

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'ruby-progress'
+require_relative '../lib/ruby-progress'
 require 'fileutils'
 require 'optparse'
 require 'json'
@@ -25,13 +25,19 @@ module PrgCLI
     when 'twirl'
       TwirlCLI.run
     when '--list-styles'
+      list_styles
+      exit
+    when '--show-styles'
       show_styles
       exit
+    when '--stop-all'
+      success = stop_all_processes
+      exit(success ? 0 : 1)
     when '-v', '--version'
       puts "prg version #{RubyProgress::VERSION}"
-      puts '  ripple - Text ripple animation with color effects'
-      puts '  worm   - Unicode wave animation with customizable styles'
-      puts '  twirl  - Spinner animation with various indicator styles'
+      puts "  ripple - Text ripple animation with color effects (v#{RubyProgress::RIPPLE_VERSION})"
+      puts "  worm   - Unicode wave animation with customizable styles (v#{RubyProgress::WORM_VERSION})"
+      puts "  twirl  - Spinner animation with various indicator styles (v#{RubyProgress::TWIRL_VERSION})"
       exit
     when '-h', '--help', 'help'
       show_help
@@ -59,6 +65,8 @@ module PrgCLI
           -v, --version    Show version information
           -h, --help       Show this help message
           --list-styles    List all available styles for all subcommands
+          --show-styles    Show visual previews of all styles for all subcommands
+          --stop-all       Stop all prg processes
 
       EXAMPLES:
           prg ripple "Loading..." --style rainbow --speed fast
@@ -92,21 +100,159 @@ module PrgCLI
     # Do not chdir or close stdio: we want to be able to emit completion output
   end
 
+  def self.list_styles
+    puts '== ripple styles'
+    puts 'rainbow, inverse, caps, normal'
+    puts ''
+
+    puts '== worm styles'
+    worm_styles = RubyProgress::Worm::RIPPLE_STYLES
+    style_names = worm_styles.keys.reject { |name| name == 'cirlces_small' }
+    puts style_names.join(', ')
+    puts ''
+
+    puts '== twirl styles'
+    twirl_names = RubyProgress::INDICATORS.keys.map(&:to_s)
+    puts twirl_names.join(', ')
+  end
+
   def self.show_styles
-    puts '== ripple'
-    puts 'rainbow'
-    puts 'inverse'
-    puts 'caps'
+    show_ripple_styles
+    show_worm_styles
+    show_twirl_styles
+  end
+
+  def self.show_ripple_styles
+    puts '== ripple styles (visual effects for text)'
+
+    # Create sample text for ripple previews
+    sample_text = 'Progress'
+
+    # Rainbow preview - show with actual rainbow colors
+    rainbow_preview = sample_text.chars.map.with_index do |char, i|
+      colors = [31, 32, 33, 34, 35, 36] # red, green, yellow, blue, magenta, cyan
+      "\e[#{colors[i % colors.length]}m#{char}\e[0m"
+    end.join
+    puts "rainbow    - #{rainbow_preview}"
+
+    # Inverse preview - show with actual inverse background
+    inverse_preview = "\e[7m#{sample_text}\e[0m"
+    puts "inverse    - #{inverse_preview}"
+
+    # Caps preview
+    caps_preview = sample_text.upcase
+    puts "caps       - #{caps_preview}"
+
+    # Normal preview
+    puts "normal     - #{sample_text}"
+
+    # Show ripple effect preview with highlighted character in middle
     puts ''
-    puts '== worm'
-    puts 'circles'
-    puts 'blocks'
-    puts 'geometric'
+    puts 'Ripple effect preview (character 4 highlighted):'
+    ripple_demo = sample_text.chars.map.with_index do |char, i|
+      if i == 3 # highlight the 'g' in Progress
+        "\e[7m#{char}\e[0m" # inverse highlight
+      else
+        char
+      end
+    end.join
+    puts "normal     - #{ripple_demo}"
+
+    inverse_ripple_demo = sample_text.chars.map.with_index do |char, i|
+      if i == 3 # highlight the 'g' in Progress
+        "\e[0m#{char}\e[7m" # normal char in inverse text
+      else
+        "\e[7m#{char}\e[0m" # inverse char
+      end
+    end.join
+    puts "inverse    - \e[7m#{inverse_ripple_demo}\e[0m"
     puts ''
-    puts '== twirl'
-    RubyProgress::INDICATORS.each_key do |name|
-      puts name
+  end
+
+  def self.show_worm_styles
+    puts '== worm styles (wave animation patterns)'
+    # Load worm styles for preview
+    worm_styles = RubyProgress::Worm::RIPPLE_STYLES
+    worm_styles.each do |name, chars|
+      next if name == 'cirlces_small' # skip typo version
+
+      baseline = chars[:baseline]
+      midline = chars[:midline]
+      peak = chars[:peak]
+      preview = "#{baseline}#{baseline}#{midline}#{peak}#{midline}#{baseline}#{baseline}"
+      puts "#{name.ljust(10)} - #{preview}"
+    end
+    puts ''
+  end
+
+  def self.show_twirl_styles
+    puts '== twirl styles (spinner characters)'
+    RubyProgress::INDICATORS.each do |name, frames|
+      preview = frames.join(' ')
+      puts "#{name.to_s.ljust(12)} - #{preview}"
+    end
+  end
+
+  def self.stop_all_processes
+    current_pid = Process.pid
+
+    # Get list of prg processes excluding current process
+    prg_pids = `pgrep -f "ruby.*bin/prg"`.split.map(&:to_i).reject { |pid| pid == current_pid }
+
+    return false if prg_pids.empty?
+
+    # First try TERM signal
+    prg_pids.each do |pid|
+      Process.kill('TERM', pid)
+    rescue StandardError
+      # Ignore errors if process already terminated
+    end
+
+    # Give processes a moment to terminate gracefully
+    sleep 0.5
+
+    # Check which processes are still running and force kill them
+    still_running = `pgrep -f "ruby.*bin/prg"`.split.map(&:to_i).reject { |pid| pid == current_pid }
+    unless still_running.empty?
+      still_running.each do |pid|
+        Process.kill('KILL', pid)
+      rescue StandardError
+        # Ignore errors if process already terminated
+      end
+    end
+
+    true
+  end
+
+  def self.stop_subcommand_processes(subcommand)
+    current_pid = Process.pid
+
+    # Get list of subcommand processes excluding current process
+    subcommand_pids = `pgrep -f "ruby.*bin/prg #{subcommand}"`.split.map(&:to_i).reject { |pid| pid == current_pid }
+
+    return false if subcommand_pids.empty?
+
+    # First try TERM signal
+    subcommand_pids.each do |pid|
+      Process.kill('TERM', pid)
+    rescue StandardError
+      # Ignore errors if process already terminated
+    end
+
+    # Give processes a moment to terminate gracefully
+    sleep 0.5
+
+    # Check which processes are still running and force kill them
+    still_running = `pgrep -f "ruby.*bin/prg #{subcommand}"`.split.map(&:to_i).reject { |pid| pid == current_pid }
+    unless still_running.empty?
+      still_running.each do |pid|
+        Process.kill('KILL', pid)
+      rescue StandardError
+        # Ignore errors if process already terminated
+      end
     end
+
+    true
   end
 end
 
@@ -131,106 +277,124 @@ module RippleCLI
       message: nil # For unified interface
     }
 
-    OptionParser.new do |opts|
-      opts.banner = 'Usage: prg ripple [options] [STRING]'
-      opts.separator ''
-      opts.separator 'Animation Options:'
+    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 /^m/ then :medium
+                            when /^s/ then :slow
+                            else :medium
+                            end
+        end
 
-      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 /^m/ then :medium
-                          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('-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('--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('-d', '--direction DIRECTION', 'Animation direction (forward/bidirectional or f/b)') do |f|
-        options[:format] = f =~ /^f/i ? :forward_only : :bidirectional
-      end
+        opts.separator ''
+        opts.separator 'Command Execution:'
 
-      opts.separator ''
-      opts.separator 'Command Execution:'
+        opts.on('-c', '--command COMMAND', 'Run command during animation (optional)') do |command|
+          options[:command] = command
+        end
 
-      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('--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('--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('--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('--stdout', 'Output captured command result to STDOUT') do
-        options[:output] = :stdout
-      end
+        opts.on('--quiet', 'Suppress all output') do
+          options[:output] = :quiet
+        end
 
-      opts.on('--quiet', 'Suppress all output') do
-        options[:output] = :quiet
-      end
+        opts.separator ''
+        opts.separator 'Daemon Mode:'
 
-      opts.separator ''
-      opts.separator 'Daemon Mode:'
+        opts.on('--daemon', 'Run in background daemon mode') do
+          options[:daemon] = true
+        end
 
-      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('--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', '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('--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.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 '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.separator ''
-      opts.separator 'General:'
+        opts.on('--show-styles', 'Show available ripple styles with visual previews') do
+          PrgCLI.show_ripple_styles
+          exit
+        end
 
-      opts.on('-v', '--version', 'Show version') do
-        puts "Ripple version #{RubyProgress::VERSION}"
-        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('-h', '--help', 'Show this help') do
-        puts opts
-        exit
-      end
-    end.parse!
+        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
 
     # Daemon/status/stop handling (process these without requiring text)
     if options[:status]
@@ -353,7 +517,7 @@ module RippleCLI
         end
       end
 
-      File.delete(pid_file) if File.exist?(pid_file)
+      FileUtils.rm_f(pid_file)
     end
   end
 end
@@ -413,7 +577,7 @@ module WormCLI
       )
     ensure
       # Clean up PID file
-      File.delete(pid_file) if File.exist?(pid_file)
+      FileUtils.rm_f(pid_file)
     end
   end
 
@@ -514,6 +678,11 @@ module WormCLI
       end
       opts.on('--stop-checkmark', 'When stopping, include a success checkmark') { options[:stop_checkmark] = true }
 
+      opts.on('--stop-all', 'Stop all prg worm processes') do
+        success = PrgCLI.stop_subcommand_processes('worm')
+        exit(success ? 0 : 1)
+      end
+
       opts.on('--stop-pid FILE', 'Stop daemon by reading PID from file (deprecated: use --stop [--pid-file])') do |file|
         RubyProgress::Daemon.stop_daemon_by_pid_file(file)
         exit
@@ -527,6 +696,16 @@ module WormCLI
       opts.separator ''
       opts.separator 'General:'
 
+      opts.on('--show-styles', 'Show available worm styles with visual previews') do
+        PrgCLI.show_worm_styles
+        exit
+      end
+
+      opts.on('--stop-all', 'Stop all prg worm processes') do
+        success = PrgCLI.stop_subcommand_processes('worm')
+        exit(success ? 0 : 1)
+      end
+
       opts.on('-v', '--version', 'Show version') do
         puts "Worm version #{RubyProgress::VERSION}"
         exit
@@ -539,6 +718,12 @@ module WormCLI
     end.parse!
 
     options
+  rescue OptionParser::InvalidOption => e
+    puts "Invalid option: #{e.args.first}"
+    puts ''
+    puts 'Usage: prg worm [options]'
+    puts "Run 'prg worm --help' for more information."
+    exit 1
   end
 end
 
@@ -675,7 +860,7 @@ module TwirlCLI
         end
       end
 
-      File.delete(pid_file) if File.exist?(pid_file)
+      FileUtils.rm_f(pid_file)
     end
   end
 
@@ -705,8 +890,8 @@ module TwirlCLI
         options[:message] = message
       end
 
-      opts.on('--style STYLE', 'Spinner style (see --list-styles for options)') do |style|
-        options[:style] = style.to_sym
+      opts.on('--style STYLE', 'Spinner style (see --show-styles for options)') do |style|
+        options[:style] = style
       end
 
       opts.separator ''
@@ -780,6 +965,16 @@ module TwirlCLI
       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
@@ -792,6 +987,12 @@ module TwirlCLI
     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
 
@@ -799,7 +1000,7 @@ end
 class TwirlSpinner
   def initialize(message, options = {})
     @message = message
-    @style = options[:style] || :dots
+    @style = parse_style(options[:style] || 'dots')
     @speed = parse_speed(options[:speed] || 'medium')
     @frames = RubyProgress::INDICATORS[@style] || RubyProgress::INDICATORS[:dots]
     @index = 0
@@ -807,16 +1008,75 @@ class TwirlSpinner
 
   def animate
     if @message && !@message.empty?
-      print "\r#{@message} #{@frames[@index]}"
+      $stderr.print "\r\e[2K#{@message} #{@frames[@index]}"
     else
-      print "\r#{@frames[@index]}"
+      $stderr.print "\r\e[2K#{@frames[@index]}"
     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
+
+    # First, try exact match (convert string keys to symbols for comparison)
+    indicator_keys = RubyProgress::INDICATORS.keys.map(&:to_s)
+    return style_lower.to_sym if indicator_keys.include?(style_lower)
+
+    # Then try prefix matching - keys that start with the input
+    prefix_matches = indicator_keys.select do |key|
+      key.downcase.start_with?(style_lower)
+    end
+
+    unless prefix_matches.empty?
+      # For prefix matches, return the shortest one
+      best_match = prefix_matches.min_by(&:length)
+      return best_match.to_sym
+    end
+
+    # Try character-by-character fuzzy matching for partial inputs
+    # Find keys where the input characters appear in order (not necessarily contiguous)
+    fuzzy_matches = indicator_keys.select do |key|
+      key_chars = key.downcase.chars
+      input_chars = style_lower.chars
+
+      # Check if all input characters appear in order in the key
+      input_chars.all? do |char|
+        idx = key_chars.index(char)
+        if idx
+          key_chars = key_chars[idx + 1..-1] # Remove matched chars and continue
+          true
+        else
+          false
+        end
+      end
+    end
+
+    unless fuzzy_matches.empty?
+      # Sort by length (prefer shorter keys)
+      best_match = fuzzy_matches.min_by(&:length)
+      return best_match.to_sym
+    end
+
+    # Fallback to substring matching
+    substring_matches = indicator_keys.select do |key|
+      key.downcase.include?(style_lower)
+    end
+
+    unless substring_matches.empty?
+      best_match = substring_matches.min_by(&:length)
+      return best_match.to_sym
+    end
+
+    # Default fallback
+    :dots
+  end
+
   def parse_speed(speed)
     case speed.to_s.downcase
     when /^f/, '1', '2', '3'