markdown_exec 2.8.3 → 2.8.5

data/lib/shell_session.rb

@@ -0,0 +1,439 @@
+#!/usr/bin/env -S bundle exec ruby -r./lib/ww
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+require 'open3'
+
+STATUS_SUCCESS = 0
+
+# ShellSession provides an interactive bash session to execute commands,
+# capturing both standard output and standard error separately with timestamps.
+# Each output line is stored as a hash containing its text and the time it was received.
+class ShellSession
+  attr_reader :exitstatus, :output, :lines, :stdout, :stderr, :stdout_lines,
+              :stderr_lines, :waiting_for_input
+
+  def initialize(setup_command = nil)
+    # Open a persistent bash session with separate stdout and stderr streams.
+    @stdin, @stdout_stream, @stderr_stream, @wait_thr = Open3.popen3('bash')
+    @stdin.flush
+
+    # Random boundary marker between commands.
+    @boundary = Random.new.rand.to_s
+
+    # Line sequence counter
+    @line_counter = 0
+
+    # Most recent command.
+    @command = ''
+
+    # Buffers for captured output.
+    @stdout_lines = []
+    @stderr_lines = []
+    @output = ''
+    @lines = []
+    @stdout = ''
+    @stderr = ''
+    @waiting_for_input = false
+
+    return @exitstatus = STATUS_SUCCESS if setup_command.nil? || setup_command.strip.empty?
+
+    run_command(setup_command)
+  end
+
+  # Executes a command in the bash session and returns its output.
+  # Stdout and stderr are captured separately with a timestamp for each line.
+  #
+  # @param command [String] The command to execute.
+  # @param interactive [Boolean] Whether this command expects user input
+  # @return [Hash] A hash containing :status, :output (stdout), :stdout, and :stderr.
+  def run_command(command, interactive = false)
+    @exitstatus = STATUS_SUCCESS
+    @command = command
+    @waiting_for_input = false
+    return { output: '', status: STATUS_SUCCESS,
+             stderr: '', stdout: '' } if command.nil? || command.strip.empty?
+
+    # Clear previous command output.
+    @stdout_lines = []
+    @stderr_lines = []
+
+    # Send the command to the shell.
+    @stdin.puts command
+    @stdin.flush
+    
+    # For non-interactive commands, immediately send the boundary marker
+    unless interactive
+      @stdin.puts "\n_exitstatus=\"$?\""
+      @stdin.puts "echo '#{@boundary}'"
+      @stdin.puts 'echo $_exitstatus'
+      @stdin.flush
+    end
+
+    done = false
+    # Add timeout to prevent infinite loops
+    timeout = Time.now + 10 # 10 second timeout
+
+    # Loop to concurrently read stdout and stderr.
+    until done
+      # Check if stdin is ready for writing (process is waiting for input)
+      begin
+        stdin_ready = IO.select(nil, [@stdin], nil, 0)
+        @waiting_for_input = interactive && !stdin_ready.nil? && stdin_ready[1].include?(@stdin)
+      rescue IOError, Errno::EBADF
+        # Handle closed file descriptors
+        @waiting_for_input = false
+      end
+      
+      begin
+        ready = IO.select([@stdout_stream, @stderr_stream], nil, nil, 0.1)
+      rescue IOError, Errno::EBADF
+        # Handle closed file descriptors
+        break
+      end
+      
+      if Time.now > timeout
+        @waiting_for_input = false
+        # Send boundary marker to finish the command
+        @stdin.puts "\n_exitstatus=\"$?\""
+        @stdin.puts "echo '#{@boundary}'"
+        @stdin.puts 'echo $_exitstatus'
+        @stdin.flush
+        break
+      end
+
+      next unless ready # Skip if no IO is ready
+
+      ready[0].each do |io|
+        if io == @stdout_stream
+          begin
+            line = @stdout_stream.gets
+          rescue IOError
+            next
+          end
+          next if line.nil?
+
+          ts = Time.now
+          if line.include?(@boundary)
+            prefix = line[0...line.index(@boundary)]
+            add_stdout_line(timestamp: ts, line: prefix) unless prefix.empty?
+            # Read exit status from the next stdout line.
+            begin
+              status_line = @stdout_stream.gets
+              @exitstatus = status_line.strip.to_i if status_line
+            rescue IOError
+              # Handle closed file descriptors
+            end
+            done = true
+            break
+          else
+            add_stdout_line(timestamp: ts, line: line)
+          end
+        elsif io == @stderr_stream
+          begin
+            line = @stderr_stream.gets
+          rescue IOError
+            next
+          end
+          next if line.nil?
+
+          ts = Time.now
+          add_stderr_line(timestamp: ts, line: line)
+        end
+      end
+    end
+
+    # Replace the potentially hanging stderr capture with a non-blocking check
+    begin
+      if (ready = IO.select([@stderr_stream], nil, nil, 0.1))
+        ready[0].each do |io|
+          begin
+            while io.wait_readable(0.1) && (line = io.read_nonblock(4096))
+              ts = Time.now
+              line.each_line do |l|
+                add_stderr_line(timestamp: ts, line: l)
+              end
+            end
+          rescue IO::WaitReadable, IOError, Errno::EBADF
+            # No more data available right now or closed file descriptor
+          rescue EOFError
+            # End of stream reached
+          end
+        end
+      end
+    rescue IOError, Errno::EBADF
+      # Handle closed file descriptors
+    end
+
+    # Prepare outputs.
+    @output = @stdout_lines.map { |entry| entry[:line] }.join
+    @stdout = @output
+    @stderr = @stderr_lines.map { |entry| entry[:line] }.join
+    @lines = @stdout_lines.map { |entry| entry[:line] }
+
+    { status: @exitstatus, output: @output, stdout: @stdout, stderr: @stderr }
+  end
+
+  # Closes the bash session.
+  def close
+    @stdin.puts 'exit'
+    @stdin.flush
+    @stdin.close
+    @stdout_stream.close
+    @stderr_stream.close
+    @wait_thr.join
+  end
+
+  # Ensures the shell session is closed when the object is garbage collected.
+  def finalize
+    close unless @stdin.closed?
+  end
+
+  # Sends input to the running process
+  # @param input [String] The input to send to the process
+  def send_input(input)
+    return unless @waiting_for_input
+    
+    begin
+      @stdin.puts(input)
+      @stdin.flush
+    rescue IOError, Errno::EBADF
+      @waiting_for_input = false
+      return
+    end
+    
+    # After sending input, we need to check if we're still waiting
+    # Give a small delay for the process to consume the input
+    sleep 0.2
+    
+    # Check if stdin is still ready for writing
+    begin
+      stdin_ready = IO.select(nil, [@stdin], nil, 0)
+      @waiting_for_input = !stdin_ready.nil? && stdin_ready[1].include?(@stdin)
+    rescue IOError, Errno::EBADF
+      @waiting_for_input = false
+    end
+    
+    # If we're no longer waiting for input, send the boundary marker
+    unless @waiting_for_input
+      begin
+        @stdin.puts "\n_exitstatus=\"$?\""
+        @stdin.puts "echo '#{@boundary}'"
+        @stdin.puts 'echo $_exitstatus'
+        @stdin.flush
+      rescue IOError, Errno::EBADF
+        # Handle closed file descriptors
+      end
+    end
+  end
+
+  # Checks if the process is waiting for input
+  # @return [Boolean] True if the process is waiting for input
+  def waiting_for_input?
+    @waiting_for_input
+  end
+
+  private
+
+  def add_stdout_line(timestamp:, line:)
+    @stdout_lines << { timestamp: timestamp, line: line,
+                       sequence: @line_counter }
+    @line_counter += 1
+  end
+
+  def add_stderr_line(timestamp:, line:)
+    @stderr_lines << { timestamp: timestamp, line: line,
+                       sequence: @line_counter }
+    @line_counter += 1
+  end
+end
+
+return if $PROGRAM_NAME != __FILE__
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+require 'minitest/autorun'
+
+class ShellSessionTest < Minitest::Test
+  def setup
+    @shell = ShellSession.new
+  end
+
+  def teardown
+    @shell.close
+  end
+
+  def test_initialize_without_setup_command
+    Timeout.timeout(5) do
+      assert_equal STATUS_SUCCESS, @shell.exitstatus
+      assert_empty @shell.output
+      assert_empty @shell.lines
+    end
+  end
+
+  def test_initialize_with_setup_command
+    Timeout.timeout(5) do
+      shell = ShellSession.new('echo "setup complete"')
+      assert_equal STATUS_SUCCESS, shell.exitstatus
+      assert_equal 'setup complete', shell.output.strip
+      shell.close
+    end
+  end
+
+  def test_run_command_with_empty_command
+    Timeout.timeout(5) do
+      result = @shell.run_command('')
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_empty result[:output]
+    end
+  end
+
+  def test_run_command_with_nil_command
+    Timeout.timeout(5) do
+      result = @shell.run_command(nil)
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_empty result[:output]
+    end
+  end
+
+  def test_run_command_echo
+    Timeout.timeout(5) do
+      result = @shell.run_command('echo "hello world"')
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_equal 'hello world', result[:output].strip
+    end
+  end
+
+  def test_run_command_with_multiple_lines
+    Timeout.timeout(5) do
+      result = @shell.run_command("echo 'line1'\necho 'line2'")
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_equal "line1\nline2\n", result[:output]
+      assert_equal %w[line1 line2],
+                   @shell.lines.map(&:strip).reject(&:empty?)
+    end
+  end
+
+  def test_run_command_with_error
+    Timeout.timeout(5) do
+      result = @shell.run_command('nonexistent_command')
+      refute_equal STATUS_SUCCESS, result[:status]
+    end
+  end
+
+  def test_run_multiple_commands_in_sequence
+    Timeout.timeout(5) do
+      @shell.run_command('echo "first"')
+      result = @shell.run_command('echo "second"')
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_equal 'second', result[:output].strip
+    end
+  end
+
+  def test_close_and_reopen
+    Timeout.timeout(5) do
+      @shell.close
+      assert @shell.instance_variable_get(:@stdin).closed?
+
+      # Create new session.
+      @shell = ShellSession.new
+      result = @shell.run_command('echo "test"')
+      assert_equal STATUS_SUCCESS, result[:status]
+    end
+  end
+
+  def test_stdout_and_stderr_separation
+    Timeout.timeout(5) do
+      result = @shell.run_command('echo "to stdout" && echo "to stderr" >&2')
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_equal 'to stdout', result[:stdout].strip
+      assert_equal 'to stderr', result[:stderr].strip
+    end
+  end
+
+  def test_stdout_and_stderr_timestamps
+    Timeout.timeout(5) do
+      @shell.run_command('echo "stdout line" && echo "stderr line" >&2')
+
+      stdout_entry = @shell.stdout_lines.first
+      stderr_entry = @shell.stderr_lines.first
+
+      assert_instance_of Time, stdout_entry[:timestamp]
+      assert_instance_of Time, stderr_entry[:timestamp]
+      assert_equal "stdout line\n", stdout_entry[:line]
+      assert_equal "stderr line\n", stderr_entry[:line]
+      assert_equal 0, stdout_entry[:sequence]
+      assert_equal 1, stderr_entry[:sequence]
+    end
+  end
+
+  def test_stderr_only_output
+    Timeout.timeout(5) do
+      result = @shell.run_command('echo "error message" >&2')
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_empty result[:stdout]
+      assert_equal 'error message', result[:stderr].strip
+    end
+  end
+
+  def test_interleaved_stdout_stderr
+    Timeout.timeout(5) do
+      cmd = <<~SHELL
+        echo "out1"
+        sleep 0.1
+        echo "err1" >&2
+        sleep 0.1
+        echo "out2"
+        sleep 0.1
+        echo "err2" >&2
+      SHELL
+
+      result = @shell.run_command(cmd)
+      assert_equal STATUS_SUCCESS, result[:status]
+      assert_equal "out1\nout2\n", result[:stdout]
+      assert_equal "err1\nerr2\n", result[:stderr]
+
+      # Verify sequence numbers
+      all_lines = (@shell.stdout_lines + @shell.stderr_lines).sort_by do |entry|
+        entry[:sequence]
+      end
+      assert_equal(%W[out1\n err1\n out2\n err2\n], all_lines.map do |entry|
+                                                      entry[:line]
+                                                    end)
+      assert_equal([0, 1, 2, 3], all_lines.map { |entry| entry[:sequence] })
+    end
+  end
+
+  def test_detect_waiting_for_input
+    # Skip this test for now until we can fix the interactive command handling
+    skip "Skipping due to issues with interactive command handling"
+  end
+  
+  def test_send_input_when_not_waiting_does_nothing
+    Timeout.timeout(5) do
+      # Run a command that doesn't wait for input
+      @shell.run_command('echo "No input needed"')
+      
+      # Verify we're not waiting for input
+      refute @shell.waiting_for_input?, "Should not be waiting for input"
+      
+      # Sending input should have no effect
+      @shell.send_input("ignored input")
+      
+      # Output should be unchanged
+      assert_equal "No input needed\n", @shell.output
+    end
+  end
+  
+  def test_waiting_for_input_predicate_method
+    # Skip this test for now until we can fix the interactive command handling
+    skip "Skipping due to issues with interactive command handling"
+  end
+  
+  def test_multiple_input_prompts
+    # Skip this test for now until we can fix the interactive command handling
+    skip "Skipping due to issues with interactive command handling"
+  end
+end

data/lib/streams_out.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 # encoding=utf-8

data/lib/string_util.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 # encoding=utf-8
@@ -19,3 +18,14 @@ module StringUtil
     end
   end
 end
+
+class String
+  unless method_defined?(:present?)
+    # Checks if the string contains any non-whitespace characters.
+    # @return [Boolean] Returns true if the string contains non-whitespace
+    # characters, false otherwise.
+    def present?
+      !strip.empty?
+    end
+  end
+end

data/lib/success_result.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env -S bundle exec ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+# frozen_string_literal: true
+
+require 'singleton'
+
+##
+# SuccessResult represents a successful outcome when no specific result value is produced.
+#
+# This class follows the Null Object pattern for successful cases, ensuring a consistent
+# interface with methods such as #success? and #failure?. It is implemented as a singleton,
+# meaning there is only one instance of SuccessResult available.
+#
+# Example:
+#   result = SomeService.call
+#   if result.success?
+#     # proceed knowing the operation succeeded
+#   else
+#     # handle failure
+#   end
+#
+class SuccessResult
+  include Singleton
+
+  ##
+  # Indicates that the result is a success.
+  #
+  # @return [Boolean] always true for SuccessResult
+  def success?
+    true
+  end
+
+  ##
+  # Indicates that the result is not a failure.
+  #
+  # @return [Boolean] always false for SuccessResult
+  def failure?
+    false
+  end
+
+  ##
+  # Provides a default message for the successful result.
+  #
+  # @return [String] a message indicating success
+  def message
+    'Success'
+  end
+
+  ##
+  # Returns a string representation of this SuccessResult.
+  #
+  # @return [String]
+  def to_s
+    'SuccessResult'
+  end
+end
+
+# Default instance for ease-of-use.
+DEFAULT_SUCCESS_RESULT = SuccessResult.instance
+
+return unless $PROGRAM_NAME == __FILE__
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+require 'minitest/autorun'
+require 'mocha/minitest'
+
+require_relative 'ww'
+
+##
+# Tests for the SuccessResult class.
+#
+# This suite verifies that the SuccessResult singleton behaves as expected:
+# - It is a singleton (all calls to SuccessResult.instance return the same object)
+# - The #success? method returns true and #failure? returns false
+# - The default message and string representation are correct.
+#
+class SuccessResultTest < Minitest::Test
+  def test_singleton
+    instance1 = SuccessResult.instance
+    instance2 = SuccessResult.instance
+    assert_same instance1, instance2, "Expected the singleton instances to be identical"
+  end
+
+  def test_success_method
+    sr = SuccessResult.instance
+    assert sr.success?, "Expected success? to return true"
+  end
+
+  def test_failure_method
+    sr = SuccessResult.instance
+    refute sr.failure?, "Expected failure? to return false"
+  end
+
+  def test_message
+    sr = SuccessResult.instance
+    assert_equal 'Success', sr.message, "Expected message to be 'Success'"
+  end
+
+  def test_to_s
+    sr = SuccessResult.instance
+    assert_equal 'SuccessResult', sr.to_s, "Expected to_s to return 'SuccessResult'"
+  end
+
+  def test_default_success_result_constant
+    assert_same SuccessResult.instance, DEFAULT_SUCCESS_RESULT, "Expected DEFAULT_SUCCESS_RESULT to be the same singleton instance"
+  end
+end

data/lib/text_analyzer.rb

@@ -1,3 +1,4 @@
+#!/usr/bin/env -S bundle exec ruby
 # frozen_string_literal: true
 
 module TextAnalyzer

data/lib/ww.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 # encoding=utf-8
+require 'bundler/setup' # Bundler enforces gem versions
 require 'pp'
 require 'stringio'
 
-LOG_LEVELS = %i[debug info warn error fatal]
+LOG_LEVELS = %i[debug info warn error fatal].freeze
 
 $debug = $DEBUG || !ENV['WW'].nil?
 
@@ -15,7 +16,8 @@ if $debug && ENV['WW_MINIMUM'].nil?
 end
 
 def ww(*objs, **kwargs)
-  return objs.size == 1 ? objs.first : objs unless $debug
+  # return the last item in the list, as the label is usually first
+  return objs.last unless $debug
 
   ww0(*objs, **kwargs.merge(locations: caller_locations))
 end
@@ -55,12 +57,11 @@ def ww0(*objs,
   # Combine all parts into the final message
   header = "#{time_prefix}#{level_prefix} #{category_prefix}"
   trace = backtrace + objs
+  io = StringIO.new
   formatted_message = if single_line
-                        io = StringIO.new
                         PP.singleline_pp(trace, io)
                         "#{header} #{io.string}"
                       else
-                        io = StringIO.new
                         PP.pp(trace, io)
                         "#{header}\n#{io.string}"
                       end
@@ -76,14 +77,15 @@ def ww0(*objs,
     file.puts(formatted_message)
   end
 
-  objs.size == 1 ? objs.first : objs
+  # return the last item in the list, as the label is usually first
+  objs.last
 end
 
 class Array
   unless defined?(deref)
     def deref
-      map(&:deref).select do |line|
-        !%r{^/(vendor|\.bundle)/}.match(line)
+      map(&:deref).reject do |line|
+        %r{^/(vendor|\.bundle)/}.match(line)
       end
     end
   end