ruby-progress 1.1.9 → 1.2.4

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'optparse'
+require_relative 'worm_options'
+
+# Enhanced Worm CLI (extracted from bin/prg)
+module WormCLI
+  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
+      progress.run_daemon_mode(
+        success_message: options[:success],
+        show_checkmark: options[:checkmark],
+        control_message_file: RubyProgress::Daemon.control_message_file(pid_file)
+      )
+    ensure
+      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
+
+  # parse_cli_options is intentionally kept together; further extraction possible
+  # parse_cli_options is intentionally delegated to WormCLI::Options
+  def self.parse_cli_options
+    WormCLI::Options.parse_cli_options
+  end
+end

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

@@ -0,0 +1,156 @@
+# 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 = {}
+
+      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('--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.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
+
+      options
+    end
+  end
+end

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

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+require_relative '../utils'
+
+# Runtime helper methods for RubyProgress::Worm
+#
+# These methods implement the interactive runtime behavior (animation
+# loop, command execution, daemon mode, etc.) and were extracted from
+# RubyProgress::Worm to reduce class length and improve readability.
+module WormRunner
+  def animate(message: nil, success: nil, error: nil)
+    @message = message if message
+    @success_text = success if success
+    @error_text = error if error
+    @running = true
+
+    original_int_handler = Signal.trap('INT') do
+      @running = false
+      RubyProgress::Utils.clear_line
+      RubyProgress::Utils.show_cursor
+      exit 130
+    end
+
+    RubyProgress::Utils.hide_cursor
+    animation_thread = Thread.new { animation_loop }
+
+    begin
+      if block_given?
+        result = yield
+        @running = false
+        animation_thread.join
+        display_completion_message(@success_text, true)
+        result
+      else
+        animation_thread.join
+      end
+    rescue StandardError => e
+      @running = false
+      animation_thread.join
+      display_completion_message(@error_text || "Error: #{e.message}", false)
+      nil
+    ensure
+      $stderr.print "\r\e[2K"
+      RubyProgress::Utils.show_cursor
+      Signal.trap('INT', original_int_handler) if original_int_handler
+    end
+  end
+
+  def run_with_command
+    return unless @command
+
+    exit_code = 0
+    stdout_content = nil
+
+    begin
+      stdout_content = animate do
+        Open3.popen3(@command) do |_stdin, stdout, stderr, wait_thr|
+          captured_stdout = stdout.read
+          stderr_content = stderr.read
+          exit_code = wait_thr.value.exitstatus
+
+          unless wait_thr.value.success?
+            error_msg = @error_text || "Command failed with exit code #{exit_code}"
+            error_msg += ": #{stderr_content.strip}" if stderr_content && !stderr_content.empty?
+            raise StandardError, error_msg
+          end
+
+          captured_stdout
+        end
+      end
+
+      puts stdout_content if @output_stdout && stdout_content
+    rescue StandardError
+      exit exit_code.nonzero? || 1
+    rescue Interrupt
+      exit 130
+    end
+  end
+
+  def run_indefinitely
+    original_int_handler = Signal.trap('INT') do
+      @running = false
+      RubyProgress::Utils.clear_line
+      RubyProgress::Utils.show_cursor
+      exit 130
+    end
+
+    @running = true
+    RubyProgress::Utils.hide_cursor
+
+    begin
+      animation_loop
+    ensure
+      RubyProgress::Utils.show_cursor
+      Signal.trap('INT', original_int_handler) if original_int_handler
+    end
+  end
+
+  def stop
+    @running = false
+  end
+
+  def run_daemon_mode(success_message: nil, show_checkmark: false, control_message_file: nil)
+    @running = true
+    stop_requested = false
+
+    original_int_handler = Signal.trap('INT') { stop_requested = true }
+    Signal.trap('USR1') { stop_requested = true }
+    Signal.trap('TERM') { stop_requested = true }
+    Signal.trap('HUP')  { stop_requested = true }
+
+    RubyProgress::Utils.hide_cursor
+
+    begin
+      animation_loop_daemon_mode(stop_requested_proc: -> { stop_requested })
+    ensure
+      RubyProgress::Utils.clear_line
+      RubyProgress::Utils.show_cursor
+
+      final_message = success_message
+      final_checkmark = show_checkmark ? true : false
+      final_success = true
+
+      if control_message_file && File.exist?(control_message_file)
+        begin
+          data = JSON.parse(File.read(control_message_file))
+          final_message = data['message'] if data['message']
+          final_checkmark = data['checkmark'] if data.key?('checkmark')
+          final_success = data['success'] if data.key?('success')
+        rescue StandardError
+          # ignore parse errors
+        ensure
+          begin
+            File.delete(control_message_file)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      if final_message
+        RubyProgress::Utils.display_completion(
+          final_message,
+          success: final_success,
+          show_checkmark: final_checkmark,
+          output_stream: :stdout
+        )
+      end
+
+      Signal.trap('INT', original_int_handler) if original_int_handler
+    end
+  end
+
+  def animation_loop_step
+    return unless @running
+
+    @position ||= 0
+    @direction ||= 1
+
+    message_part = @message && !@message.empty? ? "#{@message} " : ''
+    $stderr.print "\r\e[2K#{@start_chars}#{message_part}#{generate_dots(@position, @direction)}#{@end_chars}"
+    $stderr.flush
+
+    sleep @speed
+
+    @position += @direction
+    if @position >= @length - 1
+      if @direction_mode == :forward_only
+        @position = 0
+      else
+        @direction = -1
+      end
+    elsif @position <= 0
+      @direction = 1
+    end
+  end
+
+  def animation_loop
+    position = 0
+    direction = 1
+
+    while @running
+      message_part = @message && !@message.empty? ? "#{@message} " : ''
+      $stderr.print "\r\e[2K#{@start_chars}#{message_part}#{generate_dots(position, direction)}#{@end_chars}"
+      $stderr.flush
+
+      sleep @speed
+
+      position += direction
+      if position >= @length - 1
+        if @direction_mode == :forward_only
+          position = 0
+        else
+          direction = -1
+        end
+      elsif position <= 0
+        direction = 1
+      end
+    end
+  end
+
+  def animation_loop_daemon_mode(stop_requested_proc: -> { false })
+    position = 0
+    direction = 1
+    frame_count = 0
+
+    while @running && !stop_requested_proc.call
+      message_part = @message && !@message.empty? ? "#{@message} " : ''
+
+      $stderr.print "\r\e[2K"
+
+      if (frame_count % 10).zero?
+        $stderr.print "\e[1A\e[2K"
+        $stderr.print "\r"
+      end
+
+      $stderr.print "#{message_part}#{generate_dots(position, direction)}"
+      $stderr.flush
+
+      sleep @speed
+      frame_count += 1
+
+      position += direction
+      if position >= @length - 1
+        if @direction_mode == :forward_only
+          position = 0
+        else
+          direction = -1
+        end
+      elsif position <= 0
+        direction = 1
+      end
+    end
+  end
+
+  def generate_dots(ripple_position, direction)
+    dots = Array.new(@length) { @style[:baseline] }
+
+    (0...@length).each do |i|
+      distance = (i - ripple_position).abs
+      case distance
+      when 0
+        dots[i] = @style[:peak]
+      when 1
+        if direction == -1
+          dots[i] = @style[:midline] if i > ripple_position
+        elsif i < ripple_position
+          dots[i] = @style[:midline]
+        end
+      else
+        dots[i] = @style[:baseline]
+      end
+    end
+
+    dots.join
+  end
+end

data/lib/ruby-progress/fill.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module RubyProgress
+  # Determinate progress bar with customizable fill styles
+  class Fill
+    # Built-in fill styles with empty and full characters
+    FILL_STYLES = {
+      blocks: { empty: '▱', full: '▰' },
+      classic: { empty: '-', full: '=' },
+      dots: { empty: '·', full: '●' },
+      squares: { empty: '□', full: '■' },
+      circles: { empty: '○', full: '●' },
+      ascii: { empty: '.', full: '#' },
+      bars: { empty: '░', full: '█' },
+      arrows: { empty: '▷', full: '▶' },
+      stars: { empty: '☆', full: '★' }
+    }.freeze
+
+    attr_reader :length, :style, :current_progress, :start_chars, :end_chars
+    attr_accessor :success_message, :error_message
+
+    def initialize(options = {})
+      @length = options[:length] || 20
+      @style = parse_style(options[:style] || :blocks)
+      @current_progress = 0
+      @success_message = options[:success]
+      @error_message = options[:error]
+
+      # Parse --ends characters
+      if options[:ends]
+        @start_chars, @end_chars = RubyProgress::Utils.parse_ends(options[:ends])
+      else
+        @start_chars = ''
+        @end_chars = ''
+      end
+    end
+
+    # Advance the progress bar by one step or specified increment
+    def advance(increment: 1, percent: nil)
+      @current_progress = if percent
+                            [@length * percent / 100.0, @length].min.round
+                          else
+                            [@current_progress + increment, @length].min
+                          end
+
+      render
+      completed?
+    end
+
+    # Set progress to specific percentage (0-100)
+    def percent=(percent)
+      percent = percent.clamp(0, 100) # Clamp between 0-100
+      @current_progress = (@length * percent / 100.0).round
+      render
+      completed?
+    end
+
+    # Check if progress bar is complete
+    def completed?
+      @current_progress >= @length
+    end
+
+    # Get current progress as percentage
+    def percent
+      (@current_progress.to_f / @length * 100).round(1)
+    end
+
+    # Get current progress as float (0.0-100.0) - for scripting
+    def current
+      (@current_progress.to_f / @length * 100).round(1)
+    end
+
+    # Get detailed progress status information
+    def report
+      {
+        progress: [@current_progress, @length],
+        percent: current,
+        completed: completed?,
+        style: @style
+      }
+    end
+
+    # Render the current progress bar to stderr
+    def render
+      filled = @style[:full] * @current_progress
+      empty = @style[:empty] * (@length - @current_progress)
+      bar = "#{@start_chars}#{filled}#{empty}#{@end_chars}"
+
+      $stderr.print "\r\e[2K#{bar}"
+      $stderr.flush
+    end
+
+    # Complete the progress bar and show success message
+    def complete(message = nil)
+      @current_progress = @length
+      render
+
+      completion_message = message || @success_message
+      if completion_message
+        RubyProgress::Utils.display_completion(
+          completion_message,
+          success: true,
+          show_checkmark: true,
+          output_stream: :warn
+        )
+      else
+        $stderr.puts # Just add a newline if no message
+      end
+    end
+
+    # Cancel the progress bar and show error message
+    def cancel(message = nil)
+      $stderr.print "\r\e[2K" # Clear the progress bar
+      $stderr.flush
+
+      error_msg = message || @error_message
+      return unless error_msg
+
+      RubyProgress::Utils.display_completion(
+        error_msg,
+        success: false,
+        show_checkmark: true,
+        output_stream: :warn
+      )
+    end
+
+    # Hide or show the cursor (delegated to Utils)
+    def self.hide_cursor
+      RubyProgress::Utils.hide_cursor
+    end
+
+    def self.show_cursor
+      RubyProgress::Utils.show_cursor
+    end
+
+    # Progress with block interface for library usage
+    def self.progress(options = {}, &block)
+      return unless block_given?
+
+      fill_bar = new(options)
+      Fill.hide_cursor
+
+      begin
+        fill_bar.render # Show initial empty bar
+
+        # Call the block with the fill bar instance
+        result = block.call(fill_bar)
+
+        # Handle completion based on block result or bar state
+        if fill_bar.completed? || result == true || result.nil?
+          fill_bar.complete
+        elsif result == false
+          fill_bar.cancel
+        end
+
+        result
+      rescue StandardError => e
+        fill_bar.cancel("Error: #{e.message}")
+        raise
+      ensure
+        Fill.show_cursor
+      end
+    end
+
+    private
+
+    # Parse style option into empty/full character hash
+    def parse_style(style_option)
+      case style_option
+      when Symbol, String
+        style_name = style_option.to_sym
+        if FILL_STYLES.key?(style_name)
+          FILL_STYLES[style_name]
+        else
+          FILL_STYLES[:blocks] # Default fallback
+        end
+      when Hash
+        # Allow direct hash specification: { empty: '.', full: '#' }
+        {
+          empty: style_option[:empty] || '.',
+          full: style_option[:full] || '#'
+        }
+      else
+        FILL_STYLES[:blocks] # Default fallback
+      end
+    end
+
+    class << self
+      # Parse custom style string like "custom=.#"
+      def parse_custom_style(style_string)
+        if style_string.start_with?('custom=')
+          chars = style_string.sub('custom=', '')
+
+          # Handle multi-byte characters properly
+          char_array = chars.chars
+
+          if char_array.length == 2
+            { empty: char_array[0], full: char_array[1] }
+          else
+            # Invalid custom style, return default
+            FILL_STYLES[:blocks]
+          end
+        else
+          # Try to find built-in style
+          style_name = style_string.to_sym
+          FILL_STYLES[style_name] || FILL_STYLES[:blocks]
+        end
+      end
+    end
+  end
+end