ruby-progress 1.1.9 → 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/ripple.rb

@@ -93,7 +93,8 @@ module RubyProgress
         spinner_position: false,
         caps: false,
         inverse: false,
-        output: :error
+        output: :error,
+        ends: nil
       }
       @options = defaults.merge(options)
       @string = string
@@ -104,6 +105,7 @@ module RubyProgress
       @spinner_position = @options[:spinner_position]
       @caps = @options[:caps]
       @inverse = @options[:inverse]
+      @start_chars, @end_chars = RubyProgress::Utils.parse_ends(@options[:ends])
     end
 
     def printout
@@ -138,7 +140,7 @@ module RubyProgress
         char = @rainbow ? char.rainbow(i) : char.extend(StringExtensions).light_white
         post = letters.slice!(0, letters.length).join.extend(StringExtensions).dark_white
       end
-      $stderr.print "\r\e[2K#{pre}#{char}#{post}"
+      $stderr.print "\r\e[2K#{@start_chars}#{pre}#{char}#{post}#{@end_chars}"
       $stderr.flush
     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
 
@@ -61,5 +67,29 @@ module RubyProgress
       clear_line(output_stream) if output_stream != :warn # warn already includes clear in display_completion
       display_completion(message, success: success, show_checkmark: show_checkmark, output_stream: output_stream)
     end
+
+    # Parse start/end characters for animation wrapping
+    # @param ends_string [String] Even-length string to split in half for start/end chars
+    # @return [Array<String>] Array with [start_chars, end_chars]
+    def self.parse_ends(ends_string)
+      return ['', ''] unless ends_string && !ends_string.empty?
+
+      chars = ends_string.each_char.to_a
+      return ['', ''] if chars.length.odd? || chars.empty?
+
+      mid_point = chars.length / 2
+      start_chars = chars[0...mid_point].join
+      end_chars = chars[mid_point..-1].join
+
+      [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.1.9'
-  WORM_VERSION = '1.0.4'
-  TWIRL_VERSION = '1.0.1'
-  RIPPLE_VERSION = '1.0.5'
+  # 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
@@ -64,187 +65,17 @@ module RubyProgress
       @error_text = options[:error]
       @show_checkmark = options[:checkmark] || false
       @output_stdout = options[:stdout] || false
+      @direction_mode = options[:direction] || :bidirectional
+      @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#{message_part}#{generate_dots(@position, @direction)}"
-      $stderr.flush
-
-      sleep @speed
-
-      # Update position and direction
-      @position += @direction
-      if @position >= @length - 1
-        @direction = -1
-      elsif @position <= 0
-        @direction = 1
-      end
-    end
+    include WormRunner
 
     private
 
     def display_completion_message(message, success)
       return unless message
-      
+
       mark = ''
       if @show_checkmark
         mark = success ? '✅ ' : '🛑 '
@@ -285,7 +116,15 @@ module RubyProgress
     def parse_style(style_input)
       return RIPPLE_STYLES['circles'] unless style_input && !style_input.to_s.strip.empty?
 
-      style_lower = style_input.to_s.downcase.strip
+      style_str = style_input.to_s.strip
+
+      # Check for custom style format: custom=abc or custom_abc or customXabc
+      if style_str.match(/^custom[_=](.+)$/i)
+        custom_chars = Regexp.last_match(1)
+        return parse_custom_style(custom_chars)
+      end
+
+      style_lower = style_str.downcase
 
       # First, try exact match
       return RIPPLE_STYLES[style_lower] if RIPPLE_STYLES.key?(style_lower)
@@ -339,6 +178,24 @@ module RubyProgress
       RIPPLE_STYLES['circles']
     end
 
+    def parse_custom_style(custom_chars)
+      # Split into individual characters, properly handling multi-byte characters (emojis)
+      chars = custom_chars.each_char.to_a
+
+      # Ensure we have exactly 3 characters
+      if chars.length != 3
+        # Fallback to default if not exactly 3 characters
+        return RIPPLE_STYLES['circles']
+      end
+
+      # Create custom style hash with baseline, midline, peak
+      {
+        baseline: chars[0],
+        midline: chars[1],
+        peak: chars[2]
+      }
+    end
+
     def animation_loop
       position = 0
       direction = 1
@@ -346,14 +203,18 @@ module RubyProgress
       while @running
         message_part = @message && !@message.empty? ? "#{@message} " : ''
         # Enhanced line clearing for better daemon mode behavior
-        $stderr.print "\r\e[2K#{message_part}#{generate_dots(position, direction)}"
+        $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
-          direction = -1
+          if @direction_mode == :forward_only
+            position = 0
+          else
+            direction = -1
+          end
         elsif position <= 0
           direction = 1
         end
@@ -386,7 +247,11 @@ module RubyProgress
 
         position += direction
         if position >= @length - 1
-          direction = -1
+          if @direction_mode == :forward_only
+            position = 0
+          else
+            direction = -1
+          end
         elsif position <= 0
           direction = 1
         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/fill'
 require_relative 'ruby-progress/daemon'
 
 module RubyProgress