ruby-progress 1.2.0 → 1.2.4

data/lib/ruby-progress/fill_cli.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'fileutils'
+require_relative 'cli/fill_options'
+
+module RubyProgress
+  # CLI module for Fill command
+  module FillCLI
+    class << self
+      def run
+        trap('INT') do
+          Utils.show_cursor
+          exit
+        end
+
+        options = RubyProgress::FillCLI::Options.parse_cli_options
+
+        # Handle basic output flags first
+        if options[:help]
+          puts RubyProgress::FillCLI::Options.help_text
+          exit
+        end
+
+        if options[:version]
+          puts "Fill version #{RubyProgress::FILL_VERSION}"
+          exit
+        end
+
+        if options[:show_styles]
+          show_fill_styles
+          exit
+        end
+
+        # Handle daemon control first
+        if options[:status] || options[:stop]
+          pid_file = options[:pid_file] || '/tmp/ruby-progress/fill.pid'
+          if options[:status]
+            Daemon.show_status(pid_file)
+          else
+            Daemon.stop_daemon_by_pid_file(pid_file)
+          end
+          exit
+        end
+
+        # Parse style option
+        parsed_style = parse_fill_style(options[:style])
+
+        if options[:daemon]
+          run_daemon_mode(options, parsed_style)
+        elsif options[:current]
+          show_current_percentage(options, parsed_style)
+        elsif options[:report]
+          show_progress_report(options, parsed_style)
+        elsif options[:advance] || options[:complete] || options[:cancel]
+          handle_progress_commands(options, parsed_style)
+        else
+          run_auto_advance_mode(options, parsed_style)
+        end
+      end
+
+      private
+
+      def parse_fill_style(style_option)
+        case style_option
+        when String
+          if style_option.start_with?('custom=')
+            Fill.parse_custom_style(style_option)
+          else
+            style_option.to_sym
+          end
+        else
+          style_option
+        end
+      end
+
+      def run_daemon_mode(options, parsed_style)
+        # For daemon mode, detach the process
+        PrgCLI.daemonize
+
+        pid_file = options[:pid_file] || '/tmp/ruby-progress/fill.pid'
+        FileUtils.mkdir_p(File.dirname(pid_file))
+        File.write(pid_file, Process.pid.to_s)
+
+        # Create the fill bar and show initial empty state
+        fill_options = {
+          style: parsed_style,
+          length: options[:length],
+          ends: options[:ends],
+          success: options[:success_message],
+          error: options[:error_message]
+        }
+
+        fill_bar = Fill.new(fill_options)
+        Fill.hide_cursor
+
+        begin
+          fill_bar.render # Show initial empty bar
+
+          # Set up signal handlers for daemon control
+          stop_requested = false
+          Signal.trap('INT') { stop_requested = true }
+          Signal.trap('USR1') { stop_requested = true }
+          Signal.trap('TERM') { stop_requested = true }
+
+          # Keep daemon alive until stop requested
+          sleep(0.1) until stop_requested
+        ensure
+          Fill.show_cursor
+          FileUtils.rm_f(pid_file)
+        end
+      end
+
+      def show_current_percentage(options, _parsed_style)
+        # Just output the percentage for scripting (default to 50% for demonstration)
+        percentage = options[:percent] || 50
+        puts percentage.to_f
+      end
+
+      def show_progress_report(options, parsed_style)
+        # Create a fill bar to demonstrate current progress
+        fill_options = {
+          style: parsed_style,
+          length: options[:length],
+          ends: options[:ends]
+        }
+
+        fill_bar = Fill.new(fill_options)
+
+        # Set percentage (default to 50% for demonstration)
+        fill_bar.percent = options[:percent] || 50
+
+        # Get detailed report
+        report = fill_bar.report
+
+        # Display the current progress bar and detailed status
+        fill_bar.render
+        puts "\nProgress Report:"
+        puts "  Progress: #{report[:progress][0]}/#{report[:progress][1]}"
+        puts "  Percent: #{report[:percent]}%"
+        puts "  Completed: #{report[:completed] ? 'Yes' : 'No'}"
+        puts "  Style: #{report[:style]}"
+      end
+
+      def handle_progress_commands(_options, _parsed_style)
+        # For progress commands, we assume there's a daemon running
+        # This is a simplified version - in a real implementation,
+        # we'd need IPC to communicate with the daemon
+        warn 'Progress commands require daemon mode implementation'
+        warn "Run 'prg fill --daemon' first, then use progress commands"
+        exit 1
+      end
+
+      def run_auto_advance_mode(options, parsed_style)
+        fill_options = {
+          style: parsed_style,
+          length: options[:length],
+          ends: options[:ends],
+          success: options[:success_message],
+          error: options[:error_message]
+        }
+
+        fill_bar = Fill.new(fill_options)
+        Fill.hide_cursor
+
+        begin
+          if options[:percent]
+            # Set to specific percentage
+            fill_bar.percent = options[:percent]
+            fill_bar.render
+            unless fill_bar.completed?
+              # For non-complete percentages, show the result briefly
+              sleep(0.1)
+            end
+          else
+            # Auto-advance mode
+            sleep_time = case options[:speed]
+                         when :fast then 0.1
+                         when :medium, nil then 0.2
+                         when :slow then 0.5
+                         when Numeric then 1.0 / options[:speed]
+                         else 0.3
+                         end
+
+            fill_bar.render
+            (1..options[:length]).each do
+              sleep(sleep_time)
+              fill_bar.advance
+            end
+          end
+          fill_bar.complete
+        rescue Interrupt
+          fill_bar.cancel
+        ensure
+          Fill.show_cursor
+        end
+      end
+
+      def show_fill_styles
+        puts "\nAvailable Fill Styles:"
+        puts '=' * 50
+
+        Fill::FILL_STYLES.each do |name, style|
+          print "#{name.to_s.ljust(12)} : "
+
+          # Show a sample progress bar
+          filled = style[:full] * 6
+          empty = style[:empty] * 4
+          puts "[#{filled}#{empty}] (60%)"
+        end
+
+        puts "\nCustom Style:"
+        puts "#{'custom=XY'.ljust(12)} : Specify X=empty, Y=full characters"
+        puts '             Example: --style custom=.# → [######....] (60%)'
+        puts
+      end
+    end
+  end
+end

data/lib/ruby-progress/utils.rb

@@ -49,9 +49,15 @@ module RubyProgress
       when :stderr
         warn formatted_message
       when :warn
-        warn "\e[2K#{formatted_message}"
+        # Ensure we're at the beginning of a fresh line, clear it, then display message
+        $stderr.print "\r\e[2K"
+        $stderr.flush
+        warn formatted_message
       else
-        warn "\e[2K#{formatted_message}"
+        # Ensure we're at the beginning of a fresh line, clear it, then display message
+        $stderr.print "\r\e[2K"
+        $stderr.flush
+        warn formatted_message
       end
     end
 
@@ -77,5 +83,13 @@ module RubyProgress
 
       [start_chars, end_chars]
     end
+
+    # Validate ends string: must be non-empty and even-length (handles multi-byte chars)
+    def self.ends_valid?(ends_string)
+      return false unless ends_string && !ends_string.empty?
+
+      chars = ends_string.each_char.to_a
+      !chars.empty? && (chars.length % 2).zero?
+    end
   end
 end

data/lib/ruby-progress/version.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
 module RubyProgress
-  VERSION = '1.2.0'
-  WORM_VERSION = '1.1.0'
-  TWIRL_VERSION = '1.1.0'
-  RIPPLE_VERSION = '1.1.0'
+  # Main gem version
+  VERSION = '1.2.4'
+
+  # Component-specific versions
+  WORM_VERSION = '1.1.2'
+  TWIRL_VERSION = '1.1.2'
+  RIPPLE_VERSION = '1.1.2'
+  FILL_VERSION = '1.0.1'
 end

data/lib/ruby-progress/worm.rb

@@ -4,6 +4,7 @@ require 'optparse'
 require 'open3'
 require 'json'
 require_relative 'utils'
+require_relative 'cli/worm_runner'
 
 module RubyProgress
   # Animated progress indicator with ripple effect using Unicode combining characters
@@ -68,183 +69,7 @@ module RubyProgress
       @start_chars, @end_chars = RubyProgress::Utils.parse_ends(options[:ends])
       @running = false
     end
-
-    def animate(message: nil, success: nil, error: nil, &block)
-      @message = message if message
-      @success_text = success if success
-      @error_text = error if error
-      @running = true
-
-      # Set up interrupt handler to ensure cursor is restored
-      original_int_handler = Signal.trap('INT') do
-        @running = false
-        RubyProgress::Utils.clear_line
-        RubyProgress::Utils.show_cursor
-        exit 130
-      end
-
-      # Hide cursor
-      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 # Return nil instead of re-raising when used as a progress indicator
-      ensure
-        # Always clear animation line and restore cursor
-        $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
-          # Use popen3 instead of capture3 for better signal handling
-          Open3.popen3(@command) do |stdin, stdout, stderr, wait_thr|
-            stdin.close
-            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
-
-        # 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
-      rescue Interrupt
-        exit 130
-      end
-    end
-
-    def run_indefinitely
-      # Set up interrupt handler to ensure cursor is restored
-      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
-
-      # 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_daemon_mode(stop_requested_proc: -> { 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
-
-      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
-
-      # Update position and direction
-      @position += @direction
-      if @position >= @length - 1
-        if @direction_mode == :forward_only
-          @position = 0
-        else
-          @direction = -1
-        end
-      elsif @position <= 0
-        @direction = 1
-      end
-    end
+    include WormRunner
 
     private
 

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/fill'
 require_relative 'ruby-progress/daemon'
 
 module RubyProgress

data/quick_demo.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Short demo script for interactive/manual testing of ruby-progress features.
+# Focuses on a compact set of examples used during development and quick checks.
+##
+#
+# A shorter, more focused demo script for quick testing and demonstrations.
+# This version focuses on the most impressive features without long pauses.
+# QuickDemo: small, focused demo runner used for development and CI smoke tests.
+class QuickDemo
+  def initialize
+    @gem_path = File.expand_path('bin/prg', __dir__)
+    @lib_path = File.expand_path('lib', __dir__)
+  end
+
+  def run
+    puts "\n🚀 Ruby Progress Gem v1.2.2 - Quick Demo\n"
+    puts "=========================================\n\n"
+
+    # Showcase the most impressive features
+    showcase_ends_feature
+    showcase_custom_styles
+    showcase_direction_control
+    showcase_error_handling
+
+    puts "\n✨ Demo complete! Install with: gem install ruby-progress"
+    puts "📚 GitHub: https://github.com/ttscoff/ruby-progress\n\n"
+  end
+
+  private
+
+  def showcase_ends_feature
+    puts '🎯 Universal --ends Flag (NEW in v1.2.0)'
+    puts '-' * 40
+
+    puts 'Ripple with brackets:'
+    run_cmd("ripple 'Loading...' --ends '[]' --command 'sleep 3' --success 'Bracketed!' --checkmark")
+
+    puts "\nWorm with angles:"
+    run_cmd("worm --length 10 --ends '<<>>' --command 'sleep 3' --success 'Angled!' --checkmark")
+
+    puts "\nTwirl with emojis:"
+    run_cmd("twirl --ends '♥️👍' --command 'sleep 2' --success 'Decorated!'")
+
+    puts "\n"
+  end
+
+  def showcase_custom_styles
+    puts '🎨 Custom Worm Styles (NEW in v1.2.0)'
+    puts '-' * 40
+
+    puts 'ASCII custom pattern:'
+    run_cmd("worm --length 10 --style custom=_-= --command 'sleep 3' --success 'Custom ASCII!'")
+
+    puts "\nEmoji custom pattern:"
+    run_cmd("worm --length 10 --style custom=🟦🟨🟥 --command 'sleep 3' --success 'Custom emoji!'")
+
+    puts "\n"
+  end
+
+  def showcase_direction_control
+    puts '🏃 Direction Control (NEW in v1.2.0)'
+    puts '-' * 40
+
+    puts 'Forward-only worm:'
+    run_cmd("worm --length 10 --direction forward --command 'sleep 4' --success 'Always forward!'")
+
+    puts "\nCombined features:"
+    run_cmd("worm --length 10 --style custom=.*🟡 --direction forward --ends '【】' --command 'sleep 4' --success 'Ultimate combo!'")
+
+    puts "\n"
+  end
+
+  def showcase_error_handling
+    puts '❌ Error Handling'
+    puts '-' * 40
+
+    puts 'Graceful failure:'
+    run_cmd("ripple 'Processing...' --command 'sleep 2 && exit 1' --error 'Task failed!' --checkmark")
+
+    puts "\n"
+  end
+
+  def print_command(args)
+    # ANSI color codes
+    cyan = "\e[36m"
+    bright_red = "\e[91m"
+    bright_white = "\e[97m"
+    bright_green = "\e[92m"
+    reset = "\e[0m"
+
+    # Start with the base command
+    colored_cmd = "$ #{cyan}prg#{reset}"
+
+    # Use regex to colorize the command
+    # First capture the subcommand (ripple, worm, twirl)
+    colored_args = args.gsub(/^(ripple|worm|twirl)/, "#{bright_red}\\1#{reset}")
+
+    # Colorize flags (--flag-name) in bright white and their values in bright green
+    colored_args = colored_args.gsub(/(--[\w-]+)(\s+|=)('[^']*'|"[^"]*"|\S+)/) do |_match|
+      flag = ::Regexp.last_match(1)
+      separator = ::Regexp.last_match(2)
+      value = ::Regexp.last_match(3)
+      "#{bright_white}#{flag}#{reset}#{separator}#{bright_green}#{value}#{reset}"
+    end
+
+    # Colorize short flags (-f) in bright white and their values in bright green
+    colored_args = colored_args.gsub(/(-[a-zA-Z])(\s+)('[^']*'|"[^"]*"|\S+)/) do |_match|
+      flag = ::Regexp.last_match(1)
+      separator = ::Regexp.last_match(2)
+      value = ::Regexp.last_match(3)
+      "#{bright_white}#{flag}#{reset}#{separator}#{bright_green}#{value}#{reset}"
+    end
+
+    puts "#{colored_cmd} #{colored_args}"
+  end
+
+  def run_cmd(args)
+    full_cmd = "ruby -I #{@lib_path} #{@gem_path} #{args}"
+    print_command(args)
+    system(full_cmd)
+    puts
+  end
+end
+
+# Quick execution
+if __FILE__ == $PROGRAM_NAME
+  begin
+    QuickDemo.new.run
+  rescue Interrupt
+    puts "\n\nDemo stopped. Thanks!"
+  end
+end