ruby-progress 1.2.0 → 1.3.1

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

@@ -0,0 +1,282 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+require 'open3'
+require 'json'
+require_relative '../utils'
+require_relative '../output_capture'
+
+# 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 = if $stdout.tty? && @output_stdout
+                         oc = RubyProgress::OutputCapture.new(
+                           command: @command,
+                           lines: @output_lines || 3,
+                           position: @output_position || :above
+                         )
+                         oc.start
+                         @output_capture = oc
+                         animate do
+                           oc.wait
+                         end
+                         @output_capture = nil
+                         oc.lines.join("\n")
+                       else
+                         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
+                       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} " : ''
+    @output_capture&.redraw($stderr)
+    $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} " : ''
+      @output_capture&.redraw($stderr)
+      $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} " : ''
+      @output_capture&.redraw($stderr)
+
+      $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
+
+# rubocop:enable Metrics/ModuleLength

data/lib/ruby-progress/daemon.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'fileutils'
 
 module RubyProgress
   module Daemon
@@ -14,6 +15,70 @@ module RubyProgress
       "#{pid_file}.msg"
     end
 
+    # Resolve a job directory for the daemon based on pid_file or name.
+    # If pid_file is '/tmp/ruby-progress/mytask.pid' -> jobs dir '/tmp/ruby-progress/mytask.jobs'
+    def job_dir_for_pid(pid_file)
+      base = File.basename(pid_file, '.*')
+      File.join(File.dirname(pid_file), "#{base}.jobs")
+    end
+
+    # Process available job files in job_dir. Each job is a JSON file with {"id","command","meta"}.
+    # This method polls the directory and yields each parsed job hash to the provided block.
+    def process_jobs(job_dir, poll_interval: 0.2)
+      FileUtils.mkdir_p(job_dir)
+
+      loop do
+        # Accept any job file ending in .json (UUID filenames are common)
+        # Ignore processed-* archives and temporary files (e.g., .tmp)
+        files = Dir.children(job_dir).select do |f|
+          f.end_with?('.json') && !f.start_with?('processed-')
+        end.sort
+
+        files.each do |f|
+          path = File.join(job_dir, f)
+          processing = "#{path}.processing"
+
+          # Claim the file atomically
+          begin
+            File.rename(path, processing)
+          rescue StandardError
+            next
+          end
+
+          job = begin
+            JSON.parse(File.read(processing))
+          rescue StandardError
+            FileUtils.rm_f(processing)
+            next
+          end
+
+          begin
+            yielded = yield(job)
+
+            # on success, write .result info and merge any returned info
+            result = { 'id' => job['id'], 'status' => 'done', 'time' => Time.now.to_i }
+            if yielded.is_a?(Hash)
+              # ensure string keys
+              extra = yielded.transform_keys(&:to_s)
+              result.merge!(extra)
+            end
+            File.write("#{processing}.result", result.to_json)
+          rescue StandardError => e
+            result = { 'id' => job['id'], 'status' => 'error', 'error' => e.message }
+            File.write("#{processing}.result", result.to_json)
+          ensure
+            begin
+              FileUtils.mv(processing, File.join(job_dir, "processed-#{f}"))
+            rescue StandardError
+              FileUtils.rm_f(processing)
+            end
+          end
+        end
+
+        sleep(poll_interval)
+      end
+    end
+
     def show_status(pid_file)
       if File.exist?(pid_file)
         pid = File.read(pid_file).strip

data/lib/ruby-progress/fill.rb

@@ -0,0 +1,215 @@
+# 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]
+      @output_capture = options[:output_capture]
+
+      # 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
+      # First redraw captured output (if any) so it appears above/below the bar
+      @output_capture&.redraw($stderr)
+
+      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