tty-command 0.1.0

data/lib/tty/command/exit_error.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+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)
+        message = ''
+        message << "Running `#{cmd_name}` failed with\n"
+        message << "  exit status: #{result.exit_status}\n"
+        message << "  stdout: #{result.out.strip.empty? ? 'Nothing written' : result.out.strip}\n"
+        message << "  stderr: #{result.err.strip.empty? ? 'Nothing written' : result.err.strip}\n"
+      end
+    end # ExitError
+  end # Command
+end # TTY

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'pastel'
+
+module TTY
+  class Command
+    module Printers
+      class Abstract
+        extend Forwardable
+
+        def_delegators :@color, :decorate
+
+        attr_reader :output, :options
+
+        # 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(output: output, enabled: enabled)
+        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(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,15 @@
+# encoding: utf-8
+
+require 'tty/command/printers/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,67 @@
+# encoding: utf-8
+
+require 'pastel'
+require 'tty/command/printers/abstract'
+
+module TTY
+  class Command
+    module Printers
+      class Pretty < Abstract
+        def print_command_start(cmd, *args)
+          message = "Running #{decorate(cmd.to_command, :yellow, :bold)}"
+          message << args.map(&:chomp).join(' ') unless args.empty?
+          write(message, cmd.uuid)
+        end
+
+        def print_command_out_data(cmd, *args)
+          message = args.map(&:chomp).join(' ')
+          write("\t#{message}", cmd.uuid)
+        end
+
+        def print_command_err_data(cmd, *args)
+          message = args.map(&:chomp).join(' ')
+          write("\t" + decorate(message, :red), cmd.uuid)
+        end
+
+        def print_command_exit(cmd, status, runtime, *args)
+          runtime = "%5.3f %s" % [runtime, pluralize(runtime, 'second')]
+          message = "Finished in #{runtime}"
+          message << " with exit status #{status}" if status
+          message << " (#{success_or_failure(status)})"
+          write(message, cmd.uuid)
+        end
+
+        # Write message out to output
+        #
+        # @api private
+        def write(message, uuid = nil)
+          uuid_needed = options.fetch(:uuid) { true }
+          out = ''
+          if uuid_needed
+            out << "[#{decorate(uuid, :green)}] " unless uuid.nil?
+          end
+          out << "#{message}\n"
+          output << out
+        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,31 @@
+# encoding: utf-8
+
+require 'pastel'
+require 'tty/command/printers/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,25 @@
+# encoding: utf-8
+
+require 'tty/command/printers/abstract'
+
+module TTY
+  class Command
+    module Printers
+      class Quiet < Abstract
+        attr_reader :output, :options
+
+        def print_command_start(cmd)
+          # quiet
+        end
+
+        def print_command_exit(cmd, *args)
+          # quiet
+        end
+
+        def write(message)
+          output.print(message)
+        end
+      end # Progress
+    end # Printers
+  end # Command
+end # TTY

data/lib/tty/command/process_runner.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'tty/command/execute'
+require 'tty/command/result'
+require 'tty/command/truncator'
+
+module TTY
+  class Command
+    class ProcessRunner
+      include Execute
+
+      # Initialize a Runner object
+      #
+      # @param [Printer] printer
+      #   the printer to use for logging
+      #
+      # @api private
+      def initialize(printer)
+        @printer = printer
+      end
+
+      # Execute child process
+      # @api public
+      def run(cmd)
+        timeout = cmd.options[:timeout]
+        @printer.print_command_start(cmd)
+        start = Time.now
+
+        spawn(cmd) do |pid, stdin, stdout, stderr|
+          stdout_data, stderr_data = read_streams(cmd, stdout, stderr)
+
+          runtime = Time.now - start
+          handle_timeout(timeout, runtime, pid)
+          status = waitpid(pid)
+
+          @printer.print_command_exit(cmd, status, runtime)
+
+          Result.new(status, stdout_data, stderr_data)
+        end
+      end
+
+      private
+
+      # @api private
+      def handle_timeout(timeout, runtime, pid)
+        return unless timeout
+
+        t = timeout - runtime
+        if t < 0.0
+          ::Process.kill(:KILL, pid)
+        end
+      end
+
+      # @api private
+      def read_streams(cmd, stdout, stderr)
+        stdout_data = ''
+        stderr_data = Truncator.new
+        timeout = cmd.options[:timeout]
+
+        stdout_thread = Thread.new do
+          begin
+            while (line = stdout.gets)
+              stdout_data << line
+              @printer.print_command_out_data(cmd, line)
+            end
+          rescue TimeoutExceeded
+            stdout.close
+          end
+        end
+
+        stderr_thread = Thread.new do
+          begin
+            while (line = stderr.gets)
+              stderr_data << line
+              @printer.print_command_err_data(cmd, line)
+            end
+          rescue TimeoutExceeded
+            stderr.close
+          end
+        end
+
+        [stdout_thread, stderr_thread].each do |th|
+          result = th.join(timeout)
+          if result.nil?
+            stdout_thread.raise(TimeoutExceeded)
+            stderr_thread.raise(TimeoutExceeded)
+          end
+        end
+        [stdout_data, stderr_data.read]
+      end
+
+      # @api private
+      def waitpid(pid)
+        ::Process.waitpid(pid, Process::WUNTRACED)
+        $?.exitstatus
+      rescue Errno::ECHILD
+        # In JRuby, waiting on a finished pid raises.
+      end
+    end # ProcessRunner
+  end # Command
+end # TTY

data/lib/tty/command/result.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module TTY
+  class Command
+    # Encapsulates the information on the command executed
+    #
+    # @api public
+    class Result
+      def initialize(status, out, err)
+        @status = status
+        @out    = out
+        @err    = err
+      end
+
+      # All data written out to process's stdout stream
+      def out
+        @out
+      end
+      alias_method :stdout, :out
+
+      # All data written out to process's stdin stream
+      def err
+        @err
+      end
+      alias_method :stderr, :err
+
+      # Information on how the process exited
+      #
+      # @api public
+      def exit_status
+        @status
+      end
+      alias_method :exitstatus, :exit_status
+      alias_method :status, :exit_status
+
+      def to_i
+        @status
+      end
+
+      def to_s
+        @status.to_s
+      end
+
+      def to_ary
+        [@out, @err]
+      end
+
+      def exited?
+        @status != nil
+      end
+      alias_method :complete?, :exited?
+
+      def success?
+        if exited?
+          @status == 0
+        else
+          false
+        end
+      end
+
+      def failure?
+        !success?
+      end
+      alias_method :failed?, :failure?
+
+      def ==(other)
+        return false unless other.is_a?(TTY::Command::Result)
+        @status == other.to_i && to_ary == other.to_ary
+      end
+    end # Result
+  end # Command
+end # TTY

data/lib/tty/command/truncator.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+module TTY
+  class Command
+    # Retains the first N bytes and the last N bytes from written content
+    #
+    # @api private
+    class Truncator
+      # Default maximum byte size for prefix & suffix
+      DEFAULT_SIZE = 32 << 10
+
+      # Create a Truncator
+      #
+      # @param [Hash] options
+      # @option options [Number] max_size
+      #
+      # @api public
+      def initialize(options = {})
+        @max_size = options.fetch(:max_size) { DEFAULT_SIZE }
+        @prefix   = ''
+        @suffix   = ''
+        @skipped  = 0
+      end
+
+      # Write content
+      #
+      # @param [String] content
+      #   the content to write
+      #
+      # @return [nil]
+      #
+      # @api public
+      def write(content)
+        content = content.to_s.dup
+
+        content = append(content, @prefix)
+
+        if (over = (content.bytesize - @max_size)) > 0
+          content = content[over..-1]
+          @skipped += over
+        end
+
+        content = append(content, @suffix)
+
+        # suffix is full but we still have content to write
+        while content.bytesize > 0
+          content = copy(content, @suffix)
+        end
+      end
+      alias_method :<<, :write
+
+      # Truncated representation of the content
+      #
+      # @return [String]
+      #
+      # @api public
+      def read
+        return @prefix if @suffix.empty?
+
+        if @skipped.zero?
+          return @prefix << @suffix
+        end
+
+        res = ''
+        res << @prefix
+        res << "\n... omitting #{@skipped} bytes ...\n"
+        res << @suffix
+        res
+      end
+      alias_method :to_s, :read
+
+      private
+
+      # Copy minimum bytes from source to destination
+      #
+      # @return [String]
+      #   the remaining content
+      #
+      # @api private
+      def copy(value, dest)
+        bytes = value.bytesize
+        n = bytes < dest.bytesize ? bytes : dest.bytesize
+
+        head, tail = dest[0...n], dest[n..-1]
+        dest.replace("#{tail}#{value[0...n]}")
+        @skipped += head.bytesize
+        value[n..-1]
+      end
+
+      # Append value to destination
+      #
+      # @param [String] value
+      #
+      # @param [String] dst
+      #
+      # @api private
+      def append(value, dst)
+        remain = @max_size - dst.bytesize
+        if remain > 0
+          value_bytes = value.to_s.bytesize
+          offset = value_bytes < remain ? value_bytes : remain
+          dst << value[0...offset]
+          value = value[offset..-1]
+        end
+        value
+      end
+    end # Truncator
+  end # Command
+end # TTY