ruby-progress 1.2.0 → 1.3.1

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require_relative 'twirl_spinner'
+require_relative '../output_capture'
+
+# 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 } }
+
+      if $stdout.tty? && options[:stdout]
+        oc = RubyProgress::OutputCapture.new(
+          command: options[:command],
+          lines: options[:output_lines] || 3,
+          position: options[:output_position] || :above
+        )
+        oc.start
+
+        spinner.instance_variable_set(:@output_capture, oc)
+
+        # wait for command while spinner thread runs
+        oc.wait
+        captured_lines = oc.lines
+        captured_output = captured_lines.join("\n")
+        success = true
+      else
+        captured_output = `#{options[:command]} 2>&1`
+        success = $CHILD_STATUS.success?
+      end
+
+      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
+
+      # Start job processor thread for twirl
+      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
+      job_thread = Thread.new do
+        RubyProgress::Daemon.process_jobs(job_dir) do |job|
+          oc = RubyProgress::OutputCapture.new(
+            command: job['command'],
+            lines: options[:output_lines] || 3,
+            position: options[:output_position] || :above
+          )
+          oc.start
+
+          spinner.instance_variable_set(:@output_capture, oc)
+          oc.wait
+          captured = oc.lines.join("\n")
+          exit_status = oc.exit_status
+          spinner.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 }
+        rescue StandardError
+          # ignore
+        end
+      end
+
+      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
+
+      job_thread&.kill
+      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,79 @@
+# 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
+    @output_capture&.redraw($stderr)
+    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

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'optparse'
+require_relative 'worm_options'
+
+# Enhanced Worm CLI (extracted from bin/prg)
+module WormCLI
+  def self.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]
+
+    RubyProgress::Daemon.default_pid_file
+  end
+
+  def self.run
+    options = WormCLI::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]
+      # Detach before starting daemon logic so there's no tracked shell job
+      PrgCLI.daemonize
+      run_daemon_mode(options)
+    else
+      progress = RubyProgress::Worm.new(options)
+
+      if options[:command]
+        progress.run_with_command
+      else
+        progress.run_indefinitely
+      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)
+
+    progress = RubyProgress::Worm.new(options)
+
+    begin
+      # Start job processor thread for worm
+      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
+      job_thread = 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
+
+          oc = RubyProgress::OutputCapture.new(
+            command: job['command'],
+            lines: options[:output_lines] || 3,
+            position: options[:output_position] || :above,
+            log_path: log_path
+          )
+          oc.start
+
+          progress.instance_variable_set(:@output_capture, oc)
+          oc.wait
+          captured = oc.lines.join("\n")
+          exit_status = oc.exit_status
+          progress.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
+        end
+      end
+
+      progress.run_daemon_mode(
+        success_message: options[:success],
+        show_checkmark: options[:checkmark],
+        control_message_file: RubyProgress::Daemon.control_message_file(pid_file)
+      )
+    ensure
+      job_thread&.kill
+      FileUtils.rm_f(pid_file)
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module WormCLI
+  # Option parsing helpers for the Worm subcommand.
+  #
+  # Keeps the CLI option definitions for `prg worm` extracted from
+  # the main dispatcher to keep the CLI module small and focused.
+  module Options
+    def self.parse_cli_options
+      options = {
+        output_position: :above,
+        output_lines: 3
+      }
+      # rubocop:disable Metrics/BlockLength
+      begin
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: prg worm [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 animation') do |message|
+            options[:message] = message
+          end
+
+          opts.on('-l', '--length LENGTH', Integer, 'Number of dots to display') do |length|
+            options[:length] = length
+          end
+
+          opts.on('--style STYLE', 'Animation style (circles/blocks/geometric, c/b/g, or custom=abc)') do |style|
+            options[:style] = style
+          end
+
+          opts.on('-d', '--direction DIRECTION', 'Animation direction (forward/bidirectional or f/b)') do |direction|
+            options[:direction] = direction =~ /^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', '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
+
+          # Accept --daemon-name as an alias for --daemon-as for compatibility
+          opts.on('--daemon-name NAME', 'Alias for --daemon-as (compat)') 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.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
+          end
+
+          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 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
+          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 worm [options]'
+        puts "Run 'prg worm --help' for more information."
+        exit 1
+      end
+      # rubocop:enable Metrics/BlockLength
+      options
+    end
+  end
+end