ruby-progress 1.2.0 → 1.3.1

data/lib/ruby-progress/fill_cli.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'fileutils'
+require_relative 'cli/fill_options'
+require_relative 'output_capture'
+
+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]
+        }
+
+        # If a command is provided, capture its output and pass an OutputCapture
+        if options[:command]
+          oc = RubyProgress::OutputCapture.new(
+            command: options[:command],
+            lines: options[:output_lines] || 3,
+            position: options[:output_position] || :above
+          )
+          oc.start
+          fill_options[:output_capture] = oc
+        end
+
+        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
+          elsif options[:command]
+            # While the command runs, keep redrawing the bar (live redraw handled by Fill#render)
+            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
+            # Loop until the OutputCapture reader has finished
+            while oc.alive?
+              sleep(sleep_time)
+              fill_bar.render
+            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
+          # Ensure we wait for capture thread to finish and show cursor
+          oc&.wait
+          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/output_capture.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'io/console'
+require 'English'
+
+module RubyProgress
+  # Simple PTY-based output capture that reserves a small area of the terminal
+  # for printing captured output while the animation is drawn separately.
+  class OutputCapture
+    attr_reader :exit_status
+
+    def initialize(command:, lines: 3, position: :above, log_path: nil)
+      @command = command
+      @lines = lines
+      @position = position
+      @buffer = []
+      @buf_mutex = Mutex.new
+      @stop = false
+      @log_path = log_path
+      @log_file = nil
+    end
+
+    # Start the child process and return a thread that manages capture.
+    def start
+      @reader_thread = Thread.new { spawn_and_read }
+      self
+    end
+
+    def stop
+      @stop = true
+      @reader_thread&.join
+    end
+
+    # Wait for the reader thread to complete
+    def wait
+      @reader_thread&.join
+    end
+
+    # Return snapshot of buffered lines (thread-safe)
+    def lines
+      @buf_mutex.synchronize { @buffer.dup }
+    end
+
+    # Returns whether the reader thread is still alive
+    def alive?
+      @reader_thread&.alive? || false
+    end
+
+    # Redraw buffered output into the terminal above/below the current cursor
+    # io - IO object to write to (default $stderr)
+    def redraw(io = $stderr)
+      buf = lines
+      _rows, cols = IO.console.winsize
+
+      # Ensure we have exactly @lines entries (pad with empty strings)
+      display_lines = Array.new(@lines) { '' }
+      start = [0, buf.size - @lines].max
+      buf[start, @lines]&.each_with_index do |l, i|
+        display_lines[i + (@lines - [buf.size, @lines].min)] = l.to_s
+      end
+
+      # Save cursor, move up N lines, clear and print buffer, restore cursor
+      io.print "\e[s" # save position
+      io.print "\e[#{@lines}A"            # move up @lines
+      display_lines.each do |line|
+        io.print "\e[2K"                  # clear line
+        io.print "\r"                     # move cursor to start of line
+        io.print line[0, cols]
+        io.print "\n"
+      end
+      io.print "\e[u" # restore
+      io.flush
+    end
+
+    private
+
+    def spawn_and_read
+      PTY.spawn(@command) do |reader, _writer, pid|
+        @child_pid = pid
+        until reader.eof? || @stop
+          next unless reader.wait_readable(0.1)
+
+          chunk = reader.read_nonblock(4096, exception: false)
+          next if chunk.nil? || chunk.empty?
+
+          # lazily open log file if requested
+          if @log_path && !@log_file
+            begin
+              FileUtils.mkdir_p(File.dirname(@log_path))
+              @log_file = File.open(@log_path, 'a')
+            rescue StandardError
+              @log_file = nil
+            end
+          end
+
+          process_chunk(chunk)
+          next unless @log_file
+
+          begin
+            @log_file.write(chunk)
+            @log_file.flush
+          rescue StandardError
+            # ignore logging errors
+          end
+        end
+      end
+      begin
+        Process.wait(@child_pid) if @child_pid
+        @exit_status = $CHILD_STATUS.exitstatus if $CHILD_STATUS
+      rescue StandardError
+        @exit_status = nil
+      ensure
+        if @log_file
+          begin
+            @log_file.close
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    rescue Errno::EIO
+      # PTY finished
+    end
+
+    def process_chunk(chunk)
+      @buf_mutex.synchronize do
+        # split into lines, keep last N lines
+        chunk.each_line do |line|
+          @buffer << line.chomp
+          @buffer.shift while @buffer.size > @lines
+        end
+      end
+    end
+  end
+end

data/lib/ruby-progress/ripple.rb

@@ -140,6 +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
+      @output_capture&.redraw($stderr)
       $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
 
@@ -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.3.1'
+
+  # Component-specific versions (patch bumps)
+  WORM_VERSION = '1.1.3'
+  TWIRL_VERSION = '1.1.3'
+  RIPPLE_VERSION = '1.1.3'
+  FILL_VERSION = '1.0.3'
 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