ruby-progress 1.0.1 → 1.1.2

data/bin/ripple

@@ -1,147 +1,10 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative '../lib/ruby-progress'
-require 'optparse'
-
-# Ripple CLI implementation
-module RippleCLI
-  def self.run
-    trap('INT') do
-      RubyProgress::Utils.show_cursor
-      exit
-    end
-
-    options = {
-      speed: :medium,
-      direction: :bidirectional,
-      rainbow: false,
-      spinner: false,
-      spinner_position: :before,
-      caps: false,
-      inverse: false,
-      command: nil,
-      success_message: nil,
-      fail_message: nil,
-      complete_checkmark: false
-    }
-
-    OptionParser.new do |opts|
-      opts.banner = 'Usage: ripple [options] STRING'
-
-      opts.on('-s', '--speed SPEED', %i[fast medium slow], 'Set animation speed ((f)ast/(m)edium/(s)low)') do |s|
-        options[:speed] = case s
-                          when /^f/ then :fast
-                          when /^m/ then :medium
-                          when /^s/ then :slow
-                          else :slow
-                          end
-      end
-
-      opts.on('-r', '--rainbow', 'Enable rainbow mode') do
-        options[:rainbow] = true
-      end
-
-      opts.on('-d', '--direction DIRECTION', 'Set animation format ((f)orward/(b)ack-and-forth)') do |f|
-        options[:format] = f =~ /^f/ ? :forward_only : :bidirectional
-      end
-
-      opts.on('-i', '--inverse', 'Enable inverse mode') do
-        options[:inverse] = true
-      end
-
-      opts.on('-c', '--command COMMAND', 'Run a command during the animation') do |command|
-        options[:command] = command
-      end
-
-      opts.on('--success MESSAGE', 'Message to display on success') do |msg|
-        options[:success_message] = msg
-      end
-
-      opts.on('--fail MESSAGE', 'Message to display on error') do |msg|
-        options[:fail_message] = msg
-      end
-
-      opts.on('--checkmark') do
-        options[:complete_checkmark] = true
-      end
-
-      opts.on('--spinner TYPE', 'Display a rippling spinner with the message') do |type|
-        options[:spinner] = type.normalize_type
-      end
-
-      opts.on('--spinner-pos POSITION', 'Display spinner [b]efore or [a]fter message') do |pos|
-        options[:spinner_position] = pos =~ /^a/ ? :after : :before
-      end
-
-      opts.on('--list-spinners', 'List available spinners') do
-        out = "Spinners:\n"
-        RubyProgress::INDICATORS.each do |k, v|
-          out += "- #{k}: #{v[2]}\n"
-        end
-        puts out
-        exit
-      end
-
-      opts.on('--caps') do
-        options[:caps] = true
-      end
-
-      opts.on('--stdout', 'Output captured command result to STDOUT') do |_output|
-        options[:output] = :stdout
-      end
-
-      opts.on('--quiet', 'Suppress all output') do |_quiet|
-        options[:output] = :quiet
-      end
-
-      opts.on('-v', '--version', 'Display the version') do
-        puts "Ripple version #{RubyProgress::VERSION}"
-        exit
-      end
-
-      opts.on('-h', '--help', 'Display this help message') do
-        puts opts
-        exit
-      end
-    end.parse!
-
-    if ARGV.empty?
-      puts 'Please provide a string to animate as an argument.'
-      exit 1
-    end
-
-    if options[:command]
-      captured_output = nil
-      res = RubyProgress::Ripple.progress(ARGV.join(' '), options) do
-        captured_output = `#{options[:command]} 2>&1`
-      end
-
-      res = $?.success?
-
-      puts captured_output if options[:output] == :stdout
-      if options[:success_message]
-        message = if res
-                    options[:success_message]
-                  else
-                    options[:fail_message] || options[:success_message]
-                  end
-        RubyProgress::Ripple.complete(ARGV.join(' '), message, options[:complete_checkmark], res)
-      end
-      exit res ? 0 : 1
-    end
-
-    rippler = RubyProgress::Ripple.new(ARGV.join(' '), {
-                                         speed: options[:speed],
-                                         format: options[:format],
-                                         rainbow: options[:rainbow],
-                                         inverse: options[:inverse]
-                                       })
-    RubyProgress::Utils.hide_cursor
-    rippler.advance while true
-    RubyProgress::Utils.show_cursor
-    RubyProgress::Ripple.complete(ARGV.join(' '), options[:success_message], options[:complete_checkmark], true)
-  end
+# Thin shim to delegate to the unified prg CLI
+prg = File.expand_path(File.join(__dir__, 'prg'))
+if File.executable?(prg)
+  exec prg, 'ripple', *ARGV
+else
+  exec 'prg', 'ripple', *ARGV
 end
-
-RippleCLI.run if __FILE__ == $PROGRAM_NAME

data/bin/twirl

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Thin shim to delegate to the unified prg CLI
+prg = File.expand_path(File.join(__dir__, 'prg'))
+if File.executable?(prg)
+  exec prg, 'twirl', *ARGV
+else
+  exec 'prg', 'twirl', *ARGV
+end

data/bin/worm

@@ -1,80 +1,10 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative '../lib/ruby-progress'
-require 'optparse'
-
-# Worm CLI implementation
-module WormCLI
-  def self.run
-    options = parse_cli_options
-    progress = RubyProgress::Worm.new(options)
-
-    if options[:command]
-      progress.run_with_command
-    else
-      # Run indefinitely like ripple does when no command is specified
-      progress.run_indefinitely
-    end
-  end
-
-  def self.parse_cli_options
-    options = {}
-
-    OptionParser.new do |opts|
-      opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
-      opts.separator ''
-      opts.separator '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('-l', '--length LENGTH', Integer, 'Number of dots to display') do |length|
-        options[:length] = length
-      end
-
-      opts.on('-m', '--message MESSAGE', 'Message to display before dots') do |message|
-        options[:message] = message
-      end
-
-      opts.on('--style STYLE', 'Animation style (blocks, geometric, circles, or b/g/c)') do |style|
-        options[:style] = style
-      end
-
-      opts.on('-c', '--command COMMAND', 'Command to run (optional - runs indefinitely without command)') do |command|
-        options[:command] = command
-      end
-
-      opts.on('--success TEXT', 'Text to display on successful completion') do |text|
-        options[:success] = text
-      end
-
-      opts.on('--error TEXT', 'Text to display on error') do |text|
-        options[:error] = text
-      end
-
-      opts.on('--checkmark', 'Show checkmarks (✅/🛑) in completion messages') do
-        options[:checkmark] = true
-      end
-
-      opts.on('--stdout', 'Output captured command result to STDOUT') do
-        options[:stdout] = true
-      end
-
-      opts.on('-h', '--help', 'Show this help message') do
-        puts opts
-        exit
-      end
-
-      opts.on('-v', '--version', 'Display the version') do
-        puts "Worm version #{RubyProgress::VERSION}"
-        exit
-      end
-    end.parse!
-
-    options
-  end
+# Thin shim to delegate to the unified prg CLI
+prg = File.expand_path(File.join(__dir__, 'prg'))
+if File.executable?(prg)
+  exec prg, 'worm', *ARGV
+else
+  exec 'prg', 'worm', *ARGV
 end
-
-WormCLI.run if __FILE__ == $PROGRAM_NAME

data/examples/bash_daemon_demo.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+
+# Example bash script using ruby-progress daemon mode
+# This demonstrates how to use background progress indicators in shell scripts
+
+set -e
+
+echo "=== Bash Script with Background Progress Demo ==="
+echo
+
+# Configuration
+PID_FILE="/tmp/bash_progress.pid"
+PRG_BIN="$(dirname "$0")/../bin/prg"
+
+# Clean up function
+cleanup() {
+	if [ -f "$PID_FILE" ]; then
+		echo "Cleaning up progress indicator..."
+		"$PRG_BIN" worm --stop-pid "$PID_FILE" 2>/dev/null || true
+	fi
+}
+
+# Set up cleanup on exit
+trap cleanup EXIT
+
+echo "1. Starting background progress indicator..."
+"$PRG_BIN" worm --daemon --pid-file "$PID_FILE" \
+	--message "Processing multiple tasks..." \
+	--success "All tasks completed successfully!" \
+	--checkmark &
+
+# Give daemon a moment to start
+sleep 0.5
+
+echo "2. Executing tasks with background progress..."
+
+echo "   - Downloading files..."
+sleep 2
+
+echo "   - Processing data..."
+sleep 2
+
+echo "   - Generating reports..."
+sleep 1
+
+echo "   - Uploading results..."
+sleep 1
+
+echo "3. All tasks complete, stopping progress indicator..."
+cleanup
+
+echo
+echo "=== Script Complete ==="
+
+# Usage in your own scripts:
+#
+# # Start progress in background
+# prg worm --daemon --pid-file /tmp/my_progress.pid \
+#     --message "Working..." --success "Done!" --checkmark &
+#
+# # Do your actual work
+# long_running_command_1
+# long_running_command_2
+# long_running_command_3
+#
+# # Stop progress indicator
+# prg worm --stop-pid /tmp/my_progress.pid

data/examples/daemon_demo.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Daemon mode test script for ruby-progress
+
+require 'fileutils'
+
+puts '=== Ruby Progress Daemon Mode Demo ==='
+puts
+
+# Test directories
+test_dir = '/tmp/progress_test'
+FileUtils.mkdir_p(test_dir)
+pid_file = "#{test_dir}/progress.pid"
+
+puts "Test directory: #{test_dir}"
+puts "PID file: #{pid_file}"
+puts
+
+# Clean up any existing PID file
+File.delete(pid_file) if File.exist?(pid_file)
+
+puts '1. Starting worm progress indicator in daemon mode...'
+bin_path = File.join(File.dirname(__dir__), 'bin', 'prg')
+system("#{bin_path} worm --daemon --pid-file #{pid_file} --message 'Processing in background...' --success 'All tasks completed!' --checkmark &")
+
+# Wait a moment for daemon to start
+sleep 1
+
+if File.exist?(pid_file)
+  pid = File.read(pid_file).strip
+  puts "   ✅ Daemon started with PID: #{pid}"
+else
+  puts '   ❌ Failed to start daemon'
+  exit 1
+end
+
+puts
+puts '2. Simulating background work (5 seconds)...'
+puts '   - Task 1: Processing data...'
+sleep 2
+puts '   - Task 2: Running analysis...'
+sleep 2
+puts '   - Task 3: Generating report...'
+sleep 1
+
+puts
+puts '3. Stopping daemon...'
+system("#{bin_path} worm --stop-pid #{pid_file}")
+
+puts
+puts '4. Cleaning up...'
+FileUtils.rm_rf(test_dir)
+
+puts
+puts '=== Demo Complete ==='
+puts
+puts 'Usage in bash scripts:'
+puts '  # Start daemon'
+puts "  prg worm --daemon --pid-file /tmp/my_progress.pid --message 'Working...' --success 'Done!' &"
+puts '  '
+puts '  # Do your work'
+puts '  my_long_running_task_1'
+puts '  my_long_running_task_2'
+puts '  '
+puts '  # Stop daemon'
+puts '  prg worm --stop-pid /tmp/my_progress.pid'

data/examples/utils_demo.rb

@@ -4,49 +4,50 @@
 # Demo of RubyProgress::Utils universal utilities
 require_relative '../lib/ruby-progress'
 
-puts "=== RubyProgress::Utils Demo ==="
+puts '=== RubyProgress::Utils Demo ==='
 puts
 
 # Test cursor control
-puts "Testing cursor control..."
-print "Hiding cursor for 2 seconds..."
+puts 'Testing cursor control...'
+print 'Hiding cursor for 2 seconds...'
 RubyProgress::Utils.hide_cursor
 sleep 2
-print " showing cursor again."
+print ' showing cursor again.'
 RubyProgress::Utils.show_cursor
 puts
 puts
 
 # Test line clearing
-puts "Testing line clearing..."
-print "This line will be cleared..."
+puts 'Testing line clearing...'
+print 'This line will be cleared...'
 sleep 1
 RubyProgress::Utils.clear_line
-print "New content on the same line!"
+print 'New content on the same line!'
 puts
 puts
 
 # Test completion messages
-puts "Testing completion messages..."
+puts 'Testing completion messages...'
 
-RubyProgress::Utils.display_completion("Basic success message", success: true)
-RubyProgress::Utils.display_completion("Basic failure message", success: false)
+RubyProgress::Utils.display_completion('Basic success message', success: true)
+RubyProgress::Utils.display_completion('Basic failure message', success: false)
 
 puts
-puts "With checkmarks:"
-RubyProgress::Utils.display_completion("Success with checkmark", success: true, show_checkmark: true)
-RubyProgress::Utils.display_completion("Failure with checkmark", success: false, show_checkmark: true)
+puts 'With checkmarks:'
+RubyProgress::Utils.display_completion('Success with checkmark', success: true, show_checkmark: true)
+RubyProgress::Utils.display_completion('Failure with checkmark', success: false, show_checkmark: true)
 
 puts
-puts "Different output streams:"
-RubyProgress::Utils.display_completion("To STDOUT", success: true, show_checkmark: true, output_stream: :stdout)
-RubyProgress::Utils.display_completion("To STDERR", success: false, show_checkmark: true, output_stream: :stderr)
+puts 'Different output streams:'
+RubyProgress::Utils.display_completion('To STDOUT', success: true, show_checkmark: true, output_stream: :stdout)
+RubyProgress::Utils.display_completion('To STDERR', success: false, show_checkmark: true, output_stream: :stderr)
 
 puts
-puts "Complete with clear:"
-print "Content to be cleared and replaced..."
+puts 'Complete with clear:'
+print 'Content to be cleared and replaced...'
 sleep 1
-RubyProgress::Utils.complete_with_clear("Cleared and completed!", success: true, show_checkmark: true, output_stream: :stdout)
+RubyProgress::Utils.complete_with_clear('Cleared and completed!', success: true, show_checkmark: true,
+                                                                  output_stream: :stdout)
 
 puts
-puts "=== Demo Complete ==="
+puts '=== Demo Complete ==='

data/lib/ruby-progress/daemon.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RubyProgress
+  module Daemon
+    module_function
+
+    def default_pid_file
+      '/tmp/ruby-progress/progress.pid'
+    end
+
+    def control_message_file(pid_file)
+      "#{pid_file}.msg"
+    end
+
+    def show_status(pid_file)
+      if File.exist?(pid_file)
+        pid = File.read(pid_file).strip
+        running = system("ps -p #{pid} > /dev/null")
+        puts(running ? "Daemon running (pid #{pid})" : 'PID file present but process not running')
+        exit(running ? 0 : 1)
+      else
+        puts 'Daemon not running'
+        exit 1
+      end
+    end
+
+    def stop_daemon_by_pid_file(pid_file, message: nil, checkmark: false, error: false)
+      unless File.exist?(pid_file)
+        puts "PID file #{pid_file} not found"
+        exit 1
+      end
+
+      pid = File.read(pid_file).strip.to_i
+
+      # Write control message file if provided
+      if message || error
+        cmf = control_message_file(pid_file)
+        payload = { checkmark: checkmark, success: !error }
+        payload[:message] = message if message
+        File.write(cmf, payload.to_json)
+      end
+
+      begin
+        Process.kill('USR1', pid)
+        puts "Stop signal sent to process #{pid}"
+        sleep 0.5
+        File.delete(pid_file) if File.exist?(pid_file)
+      rescue Errno::ESRCH
+        puts "Process #{pid} not found (may have already stopped)"
+        File.delete(pid_file) if File.exist?(pid_file)
+        exit 1
+      rescue Errno::EPERM
+        puts "Permission denied sending signal to process #{pid}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/ruby-progress/utils.rb

@@ -35,7 +35,7 @@ module RubyProgress
       when :stdout
         puts formatted_message
       when :stderr
-        $stderr.puts formatted_message
+        warn formatted_message
       when :warn
         warn "\e[2K#{formatted_message}"
       else
@@ -50,4 +50,4 @@ module RubyProgress
       display_completion(message, success: success, show_checkmark: show_checkmark, output_stream: output_stream)
     end
   end
-end
+end

data/lib/ruby-progress/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyProgress
-  VERSION = '1.0.1'
+  VERSION = '1.1.2'
 end

data/lib/ruby-progress/worm.rb

@@ -2,6 +2,7 @@
 
 require 'optparse'
 require 'open3'
+require 'json'
 
 module RubyProgress
   # Animated progress indicator with ripple effect using Unicode combining characters
@@ -11,7 +12,7 @@ module RubyProgress
       'circles' => {
         baseline: '·',  # middle dot
         midline: '●',   # black circle
-        peak: '⬤'      # large circle
+        peak: '⬤' # large circle
       },
       'blocks' => {
         baseline: '▁',  # lower eighth block
@@ -70,7 +71,7 @@ module RubyProgress
           result = yield
           @running = false
           animation_thread.join
-          display_completion_message(@success_text || 'Done!', true)
+          display_completion_message(@success_text, true)
           result
         else
           animation_thread.join
@@ -113,7 +114,6 @@ module RubyProgress
 
         # Output to stdout if --stdout flag is set
         puts stdout_content if @output_stdout && stdout_content
-
       rescue StandardError => e
         # animate method handles error display, just exit with proper code
         exit exit_code.nonzero? || 1
@@ -148,6 +148,78 @@ module RubyProgress
       @running = false
     end
 
+    def run_daemon_mode(success_message: nil, show_checkmark: false, control_message_file: nil)
+      @running = true
+      stop_requested = false
+
+      # Set up signal handlers
+      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_step while @running && !stop_requested
+      ensure
+        RubyProgress::Utils.clear_line
+        RubyProgress::Utils.show_cursor
+
+        # Display stop-time completion message, preferring control file if provided
+        final_message = success_message
+        final_checkmark = show_checkmark
+        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, fallback to provided message
+          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
+
+      print "\r#{@message}#{generate_dots(@position, @direction)}"
+      $stdout.flush
+
+      sleep @speed
+
+      # Update position and direction
+      @position += @direction
+      if @position >= @length - 1
+        @direction = -1
+      elsif @position <= 0
+        @direction = 1
+      end
+    end
+
     private
 
     def display_completion_message(message, success)
@@ -237,8 +309,8 @@ module RubyProgress
           # When moving right, midline appears to the left of peak
           if direction == -1 # moving left
             dots[i] = @style[:midline] if i > ripple_position
-          else # moving right
-            dots[i] = @style[:midline] if i < ripple_position
+          elsif i < ripple_position # moving right
+            dots[i] = @style[:midline]
           end
         else
           dots[i] = @style[:baseline]
@@ -250,4 +322,4 @@ module RubyProgress
 
     # Terminal utilities moved to RubyProgress::Utils
   end
-end
+end

data/lib/ruby-progress.rb

@@ -4,6 +4,7 @@ require_relative 'ruby-progress/version'
 require_relative 'ruby-progress/utils'
 require_relative 'ruby-progress/ripple'
 require_relative 'ruby-progress/worm'
+require_relative 'ruby-progress/daemon'
 
 module RubyProgress
   # Main module for Ruby Progress indicators