ruby-progress 1.3.1 → 1.3.2

data/lib/ruby-progress/fill_cli.rb

@@ -2,11 +2,14 @@
 
 require 'optparse'
 require 'fileutils'
+require 'json'
+require 'securerandom'
 require_relative 'cli/fill_options'
 require_relative 'output_capture'
 
 module RubyProgress
   # CLI module for Fill command
+  # rubocop:disable Metrics/ClassLength
   module FillCLI
     class << self
       def run
@@ -35,11 +38,14 @@ module RubyProgress
 
         # Handle daemon control first
         if options[:status] || options[:stop]
-          pid_file = options[:pid_file] || '/tmp/ruby-progress/fill.pid'
+          pid_file = resolve_pid_file(options, :status_name)
           if options[:status]
             Daemon.show_status(pid_file)
           else
-            Daemon.stop_daemon_by_pid_file(pid_file)
+            Daemon.stop_daemon_by_pid_file(pid_file,
+                                           message: options[:stop_success],
+                                           checkmark: options[:stop_checkmark],
+                                           error: !options[:stop_error].nil?)
           end
           exit
         end
@@ -48,6 +54,17 @@ module RubyProgress
         parsed_style = parse_fill_style(options[:style])
 
         if options[:daemon]
+          # Resolve pid file and honor daemon-as/name
+          pid_file = resolve_pid_file(options, :daemon_name)
+          options[:pid_file] = pid_file
+
+          # Detach or background without detaching based on --no-detach
+          if options[:no_detach]
+            PrgCLI.backgroundize
+          else
+            PrgCLI.daemonize
+          end
+
           run_daemon_mode(options, parsed_style)
         elsif options[:current]
           show_current_percentage(options, parsed_style)
@@ -62,6 +79,14 @@ module RubyProgress
 
       private
 
+      def resolve_pid_file(options, name_key = :daemon_name)
+        return options[:pid_file] if options[:pid_file]
+
+        return "/tmp/ruby-progress/#{options[name_key]}.pid" if options[name_key]
+
+        '/tmp/ruby-progress/fill.pid'
+      end
+
       def parse_fill_style(style_option)
         case style_option
         when String
@@ -76,9 +101,6 @@ module RubyProgress
       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)
@@ -98,6 +120,71 @@ module RubyProgress
         begin
           fill_bar.render # Show initial empty bar
 
+          # Start job processor thread for fill (so daemon can accept jobs)
+          job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
+          Thread.new do
+            RubyProgress::Daemon.process_jobs(job_dir) do |job|
+              jid = job['id'] || SecureRandom.uuid
+              log_path = begin
+                File.join(File.dirname(job_dir), "#{jid}.log")
+              rescue StandardError
+                nil
+              end
+
+              if job['command']
+                oc = RubyProgress::OutputCapture.new(
+                  command: job['command'],
+                  lines: options[:output_lines] || 3,
+                  position: options[:output_position] || :above,
+                  log_path: log_path
+                )
+                oc.start
+
+                fill_bar.instance_variable_set(:@output_capture, oc)
+                oc.wait
+                captured = oc.lines.join("\n")
+                exit_status = oc.exit_status
+                fill_bar.instance_variable_set(:@output_capture, nil)
+
+                success = exit_status.to_i.zero?
+                if job['message']
+                  RubyProgress::Utils.display_completion(
+                    job['message'],
+                    success: success,
+                    show_checkmark: job['checkmark'] || false,
+                    output_stream: :stdout,
+                    icons: { success: options[:success_icon], error: options[:error_icon] }
+                  )
+                end
+
+                { 'exit_status' => exit_status, 'output' => captured, 'log_path' => log_path }
+
+              elsif job['action']
+                case job['action']
+                when 'advance'
+                  fill_bar.advance
+                  { 'status' => 'done', 'action' => 'advance' }
+                when 'percent'
+                  val = job['value'] || job['percent'] || 0
+                  fill_bar.percent = val.to_f
+                  { 'status' => 'done', 'action' => 'percent', 'value' => val }
+                when 'complete'
+                  fill_bar.complete
+                  { 'status' => 'done', 'action' => 'complete' }
+                when 'cancel'
+                  fill_bar.cancel
+                  { 'status' => 'done', 'action' => 'cancel' }
+                else
+                  { 'status' => 'error', 'error' => 'unknown action' }
+                end
+              else
+                { 'status' => 'error', 'error' => 'no command or action provided' }
+              end
+            rescue StandardError
+              nil
+            end
+          end
+
           # Set up signal handlers for daemon control
           stop_requested = false
           Signal.trap('INT') { stop_requested = true }
@@ -107,51 +194,82 @@ module RubyProgress
           # Keep daemon alive until stop requested
           sleep(0.1) until stop_requested
         ensure
+          # If a control message file exists, print its contents like other CLIs
+          cmf = RubyProgress::Daemon.control_message_file(pid_file)
+          if File.exist?(cmf)
+            begin
+              data = JSON.parse(File.read(cmf))
+              message = data['message']
+              check = if data.key?('checkmark')
+                        data['checkmark'] ? true : false
+                      else
+                        false
+                      end
+
+              success_val = if data.key?('success')
+                              data['success'] ? true : false
+                            else
+                              true
+                            end
+              if message
+                RubyProgress::Utils.display_completion(
+                  message,
+                  success: success_val,
+                  show_checkmark: check,
+                  output_stream: :stdout,
+                  icons: { success: options[:success_icon], error: options[:error_icon] }
+                )
+              end
+            rescue StandardError
+              # ignore
+            ensure
+              begin
+                File.delete(cmf)
+              rescue StandardError
+                nil
+              end
+            end
+          end
+
           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]}"
+        # Produce a simple scripting-friendly report to stdout
+        length = options[:length] || 20
+        percent = (options[:percent] || 50.0).to_f
+        style = parsed_style
+
+        fill = Fill.new(style: style, length: length)
+        fill.percent = percent
+
+        report = fill.report
+        puts 'Progress Report:'
+        puts "Progress: #{report[:progress][0]}/#{report[:progress][1]}"
+        puts "Percent: #{report[:percent]}%"
+        puts "Completed: #{report[:completed] ? 'Yes' : 'No'}"
+        puts "Style: #{report[:style].inspect}"
+        exit(0)
       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
+        # For now the progress commands are only supported in daemon mode.
+        # Return a clear error to the caller (specs assert this message exists).
         warn 'Progress commands require daemon mode implementation'
-        warn "Run 'prg fill --daemon' first, then use progress commands"
-        exit 1
+        exit(1)
+      end
+
+      def show_current_percentage(options, _parsed_style)
+        # For scripting and tests: print the current percentage to stdout and exit.
+        # If no explicit percent was provided, default to 50.0
+        percent = (options[:percent] || 50.0).to_f
+        $stdout.print("#{percent}\n")
+        exit(0)
       end
 
+      # Foreground / auto-advance / command mode when not daemonizing
       def run_auto_advance_mode(options, parsed_style)
         fill_options = {
           style: parsed_style,
@@ -161,20 +279,10 @@ module RubyProgress
           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
 
+        oc = nil
         begin
           if options[:percent]
             # Set to specific percentage
@@ -185,7 +293,19 @@ module RubyProgress
               sleep(0.1)
             end
           elsif options[:command]
-            # While the command runs, keep redrawing the bar (live redraw handled by Fill#render)
+            # Run the command with OutputCapture
+            oc = RubyProgress::OutputCapture.new(
+              command: options[:command],
+              lines: options[:output_lines] || 3,
+              position: options[:output_position] || :above,
+              log_path: nil
+            )
+            oc.start
+
+            # Attach capture to the live fill instance so it can render output
+            fill_bar.instance_variable_set(:@output_capture, oc)
+
+            # While the command runs, keep redrawing the bar
             sleep_time = case options[:speed]
                          when :fast then 0.1
                          when :medium, nil then 0.2
@@ -195,11 +315,11 @@ module RubyProgress
                          end
 
             fill_bar.render
-            # Loop until the OutputCapture reader has finished
             while oc.alive?
               sleep(sleep_time)
               fill_bar.render
             end
+            fill_bar.instance_variable_set(:@output_capture, nil)
           else
             # Auto-advance mode
             sleep_time = case options[:speed]
@@ -216,6 +336,7 @@ module RubyProgress
               fill_bar.advance
             end
           end
+
           fill_bar.complete
         rescue Interrupt
           fill_bar.cancel

data/lib/ruby-progress/ripple.rb

@@ -154,7 +154,7 @@ module RubyProgress
       RubyProgress::Utils.show_cursor
     end
 
-    def self.complete(string, message, checkmark, success)
+    def self.complete(string, message, checkmark, success, icons: {})
       display_message = message || (checkmark ? string : nil)
       return unless display_message
 
@@ -162,7 +162,8 @@ module RubyProgress
         display_message,
         success: success,
         show_checkmark: checkmark,
-        output_stream: :warn
+        output_stream: :warn,
+        icons: icons
       )
     end
 

data/lib/ruby-progress/utils.rb

@@ -13,12 +13,17 @@ module RubyProgress
     end
 
     def self.clear_line(output_stream = :stderr)
-      case output_stream
-      when :stdout
-        $stdout.print "\r\e[K"
-      else
-        $stderr.print "\r\e[K"
-      end
+      io = case output_stream
+           when :stdout
+             $stdout
+           when :stderr
+             $stderr
+           else
+             # allow passing an IO-like object (e.g. StringIO) directly
+             output_stream.respond_to?(:print) ? output_stream : $stderr
+           end
+
+      io.print "\r\e[K"
     end
 
     # Enhanced line clearing for daemon mode that handles output interruption
@@ -33,39 +38,55 @@ module RubyProgress
     # @param success [Boolean] Whether this represents success or failure
     # @param show_checkmark [Boolean] Whether to show checkmark/X symbols
     # @param output_stream [Symbol] Where to output (:stdout, :stderr, :warn)
-    def self.display_completion(message, success: true, show_checkmark: false, output_stream: :warn)
+    def self.display_completion(message, success: true, show_checkmark: false, output_stream: :warn, icons: {})
       return unless message
 
-      mark = ''
-      if show_checkmark
-        mark = success ? '✅ ' : '🛑 '
-      end
+      mark = if show_checkmark
+               icon = success ? (icons[:success] || '✅') : (icons[:error] || '🛑')
+               "#{icon} "
+             else
+               ''
+             end
 
       formatted_message = "#{mark}#{message}"
 
-      case output_stream
-      when :stdout
-        puts formatted_message
-      when :stderr
-        warn formatted_message
-      when :warn
-        # Ensure we're at the beginning of a fresh line, clear it, then display message
-        $stderr.print "\r\e[2K"
-        $stderr.flush
+      # Resolve destination IO: support symbols (:stdout/:stderr/:warn) or an IO-like object
+      dest_io = case output_stream
+                when :stdout
+                  $stdout
+                when :stderr
+                  $stderr
+                when :warn
+                  $stderr
+                else
+                  output_stream.respond_to?(:print) ? output_stream : $stderr
+                end
+
+      # Only treat explicit :stdout and :stderr as non-clearing requests.
+      # For :warn and any other/custom stream, clear the current line first.
+      unless %i[stdout stderr].include?(output_stream)
+        # Always include a leading carriage return when clearing to match
+        # terminal behavior expected by the test-suite.
+        dest_io.print "\r\e[2K"
+        dest_io.flush if dest_io.respond_to?(:flush)
+      end
+
+      # Emit the message to the resolved destination IO. Use warn/puts when targeting
+      # the standard streams to preserve familiar behavior (warn writes to $stderr).
+      if dest_io == $stdout
+        $stdout.puts formatted_message
+      elsif dest_io == $stderr
         warn formatted_message
       else
-        # 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
+        dest_io.puts formatted_message
       end
     end
 
     # Clear current line and display completion message
     # Convenience method that combines line clearing with message display
-    def self.complete_with_clear(message, success: true, show_checkmark: false, output_stream: :warn)
+    def self.complete_with_clear(message, success: true, show_checkmark: false, output_stream: :warn, icons: {})
       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)
+      display_completion(message, success: success, show_checkmark: show_checkmark, output_stream: output_stream, icons: icons)
     end
 
     # Parse start/end characters for animation wrapping

data/lib/ruby-progress/version.rb

@@ -2,11 +2,11 @@
 
 module RubyProgress
   # Main gem version
-  VERSION = '1.3.1'
+  VERSION = '1.3.2'
 
   # 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'
+  WORM_VERSION = '1.1.4'
+  TWIRL_VERSION = '1.1.4'
+  RIPPLE_VERSION = '1.1.4'
+  FILL_VERSION = '1.0.4'
 end

data/lib/ruby-progress/worm.rb

@@ -76,13 +76,14 @@ module RubyProgress
     def display_completion_message(message, success)
       return unless message
 
-      mark = ''
-      if @show_checkmark
-        mark = success ? '✅ ' : '🛑 '
-      end
-
-      # Clear animation line and output completion message on stderr
-      $stderr.print "\r\e[2K#{mark}#{message}\n"
+      # Delegate to Utils.display_completion so carriage-return and clearing
+      # behavior is consistent across all indicators and respects TTY state.
+      RubyProgress::Utils.display_completion(
+        message,
+        success: success,
+        show_checkmark: @show_checkmark,
+        output_stream: :warn
+      )
     end
 
     def parse_speed(speed_input)

data/screencast

@@ -0,0 +1,26 @@
+{"version":2,"width":146,"height":24,"timestamp":1760358387,"duration":4.124379,"env":{"SHELL":"/opt/homebrew/bin/fish","TERM":"xterm-256color"}}
+[0.002162,"o","$ bin/prg worm --command \"sleep 4\"\r\n"]
+[0.052412,"o","\u001b[?25l"]
+[0.054304,"o","\r\u001b[2K⬤··"]
+[0.260053,"o","\r\u001b[2K●⬤·"]
+[0.462807,"o","\r\u001b[2K··⬤"]
+[0.667558,"o","\r\u001b[2K·⬤●"]
+[0.86773,"o","\r\u001b[2K⬤··"]
+[1.06914,"o","\r\u001b[2K●⬤·"]
+[1.273207,"o","\r\u001b[2K··⬤"]
+[1.477782,"o","\r\u001b[2K·⬤●"]
+[1.682846,"o","\r\u001b[2K⬤··"]
+[1.885136,"o","\r\u001b[2K●⬤·"]
+[2.087746,"o","\r\u001b[2K··⬤"]
+[2.290181,"o","\r\u001b[2K·⬤●"]
+[2.494656,"o","\r\u001b[2K⬤··"]
+[2.69979,"o","\r\u001b[2K●⬤·"]
+[2.900129,"o","\r\u001b[2K··⬤"]
+[3.102774,"o","\r\u001b[2K·⬤●"]
+[3.303982,"o","\r\u001b[2K⬤··"]
+[3.507771,"o","\r\u001b[2K●⬤·"]
+[3.711678,"o","\r\u001b[2K··⬤"]
+[3.915598,"o","\r\u001b[2K·⬤●"]
+[4.120702,"o","\r\u001b[2K"]
+[4.121323,"o","\u001b[?25h"]
+[4.124379,"o",""]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-progress
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Brett Terpstra
@@ -126,7 +126,7 @@ files:
 - lib/ruby-progress/worm.rb
 - quick_demo.rb
 - readme_demo.rb
-- ruby-progress.gemspec
+- screencast
 - scripts/run_matrix_mise.fish
 - test_daemon_interruption.rb
 - test_daemon_orphan.rb

data/ruby-progress.gemspec

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/ruby-progress/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'ruby-progress'
-  spec.version = RubyProgress::VERSION
-  spec.authors = ['Brett Terpstra']
-  spec.email = ['me@brettterpstra.com']
-
-  spec.summary = 'Animated terminal progress indicators'
-  spec.description = 'Animated progress indicators for Ruby: Ripple (text ripple effects), Worm (Unicode wave animations), and Twirl (spinner indicators)'
-  spec.homepage = 'https://github.com/ttscoff/ruby-progress'
-  spec.license = 'MIT'
-  spec.required_ruby_version = '>= 2.5.0'
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = 'bin'
-  spec.executables = %w[prg ripple worm twirl fill]
-  spec.require_paths = ['lib']
-
-  # Runtime dependencies
-  # None required - uses only standard library
-
-  # Development dependencies
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '~> 1.21'
-  spec.add_development_dependency 'simplecov', '~> 0.21'
-  spec.metadata['rubygems_mfa_required'] = 'true'
-end