outstand-tty-command 0.10.0.pre

data/lib/tty/command/dry_runner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'result'
+
+module TTY
+  class Command
+    class DryRunner
+      attr_reader :cmd
+
+      def initialize(cmd, printer)
+        @cmd     = cmd
+        @printer = printer
+      end
+
+      # Show command without running
+      #
+      # @api public
+      def run!(*)
+        cmd.to_command
+        message = "#{@printer.decorate('(dry run)', :blue)} " +
+                  @printer.decorate(cmd.to_command, :yellow, :bold)
+        @printer.write(cmd, message, cmd.uuid)
+        Result.new(0, '', '')
+      end
+    end # DryRunner
+  end # Command
+end # TTY

data/lib/tty/command/exit_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TTY
+  class Command
+    # An ExitError reports an unsuccessful exit by command.
+    #
+    # The error message includes:
+    #  * the name of command executed
+    #  * the exit status
+    #  * stdout bytes
+    #  * stderr bytes
+    #
+    # @api private
+    class ExitError < RuntimeError
+      def initialize(cmd_name, result)
+        super(info(cmd_name, result))
+      end
+
+      def info(cmd_name, result)
+        "Running `#{cmd_name}` failed with\n" \
+        "  exit status: #{result.exit_status}\n" \
+        "  stdout: #{extract_output(result.out)}\n" \
+        "  stderr: #{extract_output(result.err)}\n"
+      end
+
+      def extract_output(value)
+        (value || '').strip.empty? ? 'Nothing written' : value.strip
+      end
+    end # ExitError
+  end # Command
+end # TTY

data/lib/tty/command/printers/abstract.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'pastel'
+
+module TTY
+  class Command
+    module Printers
+      class Abstract
+        extend Forwardable
+
+        def_delegators :@color, :decorate
+
+        attr_reader :output, :options
+        attr_accessor :out_data, :err_data
+
+        # Initialize a Printer object
+        #
+        # @param [IO] output
+        #   the printer output
+        #
+        # @api public
+        def initialize(output, options = {})
+          @output  = output
+          @options = options
+          @enabled = options.fetch(:color) { true }
+          @color   = ::Pastel.new(enabled: @enabled)
+
+          @out_data = ''
+          @err_data = ''
+        end
+
+        def print_command_start(cmd, *args)
+          write(cmd.to_command + "#{args.join}")
+        end
+
+        def print_command_out_data(cmd, *args)
+          write(args.join(' '))
+        end
+
+        def print_command_err_data(cmd, *args)
+          write(args.join(' '))
+        end
+
+        def print_command_exit(cmd, *args)
+          write(args.join(' '))
+        end
+
+        def write(cmd, message)
+          raise NotImplemented, "Abstract printer cannot be used"
+        end
+      end # Abstract
+    end # Printers
+  end # Command
+end # TTY

data/lib/tty/command/printers/null.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module TTY
+  class Command
+    module Printers
+      class Null < Abstract
+        def write(*)
+          # Do nothing
+        end
+      end # Null
+    end # Printers
+  end # Command
+end # TTY

data/lib/tty/command/printers/pretty.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'pastel'
+
+require_relative 'abstract'
+
+module TTY
+  class Command
+    module Printers
+      class Pretty < Abstract
+        TIME_FORMAT = "%5.3f %s".freeze
+
+        def initialize(*)
+          super
+          @uuid = options.fetch(:uuid) { true }
+        end
+
+        def print_command_start(cmd, *args)
+          message = ["Running #{decorate(cmd.to_command, :yellow, :bold)}"]
+          message << args.map(&:chomp).join(' ') unless args.empty?
+          write(cmd, message.join)
+        end
+
+        def print_command_out_data(cmd, *args)
+          message = args.map(&:chomp).join(' ')
+          write(cmd, "\t#{message}", out_data)
+        end
+
+        def print_command_err_data(cmd, *args)
+          message = args.map(&:chomp).join(' ')
+          write(cmd, "\t" + decorate(message, :red), err_data)
+        end
+
+        def print_command_exit(cmd, status, runtime, *args)
+          if cmd.only_output_on_error && !status.zero?
+            output << out_data
+            output << err_data
+          end
+
+          runtime = TIME_FORMAT % [runtime, pluralize(runtime, 'second')]
+          message = ["Finished in #{runtime}"]
+          message << " with exit status #{status}" if status
+          message << " (#{success_or_failure(status)})"
+          write(cmd, message.join)
+        end
+
+        # Write message out to output
+        #
+        # @api private
+        def write(cmd, message, data = nil)
+          cmd_set_uuid = cmd.options.fetch(:uuid, true)
+          uuid_needed = cmd.options[:uuid].nil? ? @uuid : cmd_set_uuid
+          out = []
+          if uuid_needed
+            out << "[#{decorate(cmd.uuid, :green)}] " unless cmd.uuid.nil?
+          end
+          out << "#{message}\n"
+          target = (cmd.only_output_on_error && !data.nil?) ? data : output
+          target << out.join
+        end
+
+        private
+
+        # Pluralize word based on a count
+        #
+        # @api private
+        def pluralize(count, word)
+          "#{word}#{'s' unless count.to_f == 1}"
+        end
+
+        # @api private
+        def success_or_failure(status)
+          if status == 0
+            decorate('successful', :green, :bold)
+          else
+            decorate('failed', :red, :bold)
+          end
+        end
+      end # Pretty
+    end # Printers
+  end # Command
+end # TTY

data/lib/tty/command/printers/progress.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'pastel'
+require_relative 'abstract'
+
+module TTY
+  class Command
+    module Printers
+      class Progress < Abstract
+
+        def print_command_exit(cmd, status, runtime, *args)
+          output.print(success_or_failure(status))
+        end
+
+        def write(*)
+        end
+
+        private
+
+        # @api private
+        def success_or_failure(status)
+          if status == 0
+            decorate('.', :green)
+          else
+            decorate('F', :red)
+          end
+        end
+      end # Progress
+    end # Printers
+  end # Command
+end # TTY

data/lib/tty/command/printers/quiet.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require_relative 'abstract'
+
+module TTY
+  class Command
+    module Printers
+      class Quiet < Abstract
+        attr_reader :output, :options
+
+        def print_command_start(cmd)
+          # quiet
+        end
+
+        def print_command_out_data(cmd, *args)
+          write(cmd, args.join(' '), out_data)
+        end
+
+        def print_command_err_data(cmd, *args)
+          write(cmd, args.join(' '), err_data)
+        end
+
+        def print_command_exit(cmd, status, *args)
+          unless !cmd.only_output_on_error || status.zero?
+            output << out_data
+            output << err_data
+          end
+
+          # quiet
+        end
+
+        def write(cmd, message, data = nil)
+          target = (cmd.only_output_on_error && !data.nil?) ? data : output
+          target << message
+        end
+      end # Progress
+    end # Printers
+  end # Command
+end # TTY

data/lib/tty/command/process_runner.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+require_relative 'child_process'
+require_relative 'result'
+require_relative 'truncator'
+
+module TTY
+  class Command
+    class ProcessRunner
+      # the command to be spawned
+      attr_reader :cmd
+
+      # Initialize a Runner object
+      #
+      # @param [Printer] printer
+      #   the printer to use for logging
+      #
+      # @api private
+      def initialize(cmd, printer, &block)
+        @cmd     = cmd
+        @timeout = cmd.options[:timeout]
+        @input   = cmd.options[:input]
+        @signal  = cmd.options[:signal] || "SIGKILL"
+        @binmode = cmd.options[:binmode]
+        @printer = printer
+        @block   = block
+      end
+
+      # Execute child process
+      #
+      # Write the input if provided to the child's stdin and read
+      # the contents of both the stdout and stderr.
+      #
+      # If a block is provided then yield the stdout and stderr content
+      # as its being read.
+      #
+      # @api public
+      def run!
+        @printer.print_command_start(cmd)
+        start = Time.now
+
+        pid, stdin, stdout, stderr = ChildProcess.spawn(cmd)
+
+        write_stream(stdin, @input)
+
+        stdout_data, stderr_data = read_streams(stdout, stderr)
+
+        status = waitpid(pid)
+        runtime = Time.now - start
+
+        @printer.print_command_exit(cmd, status, runtime)
+
+        Result.new(status, stdout_data, stderr_data, runtime)
+      ensure
+        [stdin, stdout, stderr].each { |fd| fd.close if fd && !fd.closed? }
+        if pid # Ensure no zombie processes
+          ::Process.detach(pid)
+          terminate(pid)
+        end
+      end
+
+      # Stop a process marked by pid
+      #
+      # @param [Integer] pid
+      #
+      # @api public
+      def terminate(pid)
+        ::Process.kill(@signal, pid) rescue nil
+      end
+
+      private
+
+      # The buffer size for reading stdout and stderr
+      BUFSIZE = 16 * 1024
+
+      # @api private
+      def handle_timeout(runtime)
+        return unless @timeout
+
+        t = @timeout - runtime
+        raise TimeoutExceeded if t < 0.0
+      end
+
+      # Write the input to the process stdin
+      #
+      # @api private
+      def write_stream(stream, input)
+        start = Time.now
+        writers = [input && stream].compact
+
+        while writers.any?
+          ready = IO.select(nil, writers, writers, @timeout)
+          raise TimeoutExceeded if ready.nil?
+
+          ready[1].each do |writer|
+            begin
+              err   = nil
+              size  = writer.write(@input)
+              input = input.byteslice(size..-1)
+            rescue IO::WaitWritable
+            rescue Errno::EPIPE => err
+              # The pipe closed before all input written
+              # Probably process exited prematurely
+              writer.close
+              writers.delete(writer)
+            end
+            if err || input.bytesize == 0
+              writer.close
+              writers.delete(writer)
+            end
+
+            # control total time spent writing
+            runtime = Time.now - start
+            handle_timeout(runtime)
+          end
+        end
+      end
+
+      # Read stdout & stderr streams in the background
+      #
+      # @param [IO] stdout
+      # @param [IO] stderr
+      #
+      # @api private
+      def read_streams(stdout, stderr)
+        stdout_data = []
+        stderr_data = Truncator.new
+
+        out_buffer = ->(line) {
+          stdout_data << line
+          @printer.print_command_out_data(cmd, line)
+          @block.(line, nil) if @block
+        }
+
+        err_buffer = ->(line) {
+          stderr_data << line
+          @printer.print_command_err_data(cmd, line)
+          @block.(nil, line) if @block
+        }
+
+        stdout_thread = read_stream(stdout, out_buffer)
+        stderr_thread = read_stream(stderr, err_buffer)
+
+        stdout_thread.join
+        stderr_thread.join
+
+        encoding = @binmode ? Encoding::BINARY : Encoding::UTF_8
+
+        [
+          stdout_data.join.force_encoding(encoding),
+          stderr_data.read.dup.force_encoding(encoding)
+        ]
+      end
+
+      def read_stream(stream, buffer)
+        Thread.new do
+          if Thread.current.respond_to?(:report_on_exception)
+            Thread.current.report_on_exception = false
+          end
+          Thread.current[:cmd_start] = Time.now
+          readers = [stream]
+
+          while readers.any?
+            ready = IO.select(readers, nil, readers, @timeout)
+            raise TimeoutExceeded if ready.nil?
+
+            ready[0].each do |reader|
+              begin
+                line = reader.readpartial(BUFSIZE)
+                buffer.(line)
+
+                # control total time spent reading
+                runtime = Time.now - Thread.current[:cmd_start]
+                handle_timeout(runtime)
+              rescue Errno::EAGAIN, Errno::EINTR
+              rescue EOFError, Errno::EPIPE, Errno::EIO # thrown by PTY
+                readers.delete(reader)
+                reader.close
+              end
+            end
+          end
+        end
+      end
+
+      # @api private
+      def waitpid(pid)
+        _pid, status = ::Process.waitpid2(pid, ::Process::WUNTRACED)
+        status.exitstatus || status.termsig if _pid
+      rescue Errno::ECHILD
+        # In JRuby, waiting on a finished pid raises.
+      end
+    end # ProcessRunner
+  end # Command
+end # TTY