tty-command 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb721a5620ec91bddc77643358783a38fb76631f
-  data.tar.gz: b0f3485e21f80e9172d1651eb661360fb3972d6f
+  metadata.gz: 0da26e779e4608d8ea38cf75801e0afa682dfd14
+  data.tar.gz: 1a8f798ca2de05727cd9217a20314a9730763cd9
 SHA512:
-  metadata.gz: 3184987586dff4f957bbeee34cf0811f60c10db0f533fe48e957f171a3a1b22485f1e4970a7b4867466deb73ad95e9b3ae30c4194753724471756aece30446de
-  data.tar.gz: 1500b854c1a69a788e49226d28403f92ee28258b608939596e1da92296ff815623ef70885e0c54751e3a8769539fc5f6c8dfd973f69c43c87f112cbf575707ce
+  metadata.gz: 6c966cec07e3ded53c89a294291e4ae9b74cdc7c0c81fb9a5843cd26bb0d7846fe14d57ae4b44756f8b5567fe40163bc27d7e33f2fedecb9826e97892002b9ba
+  data.tar.gz: d098129b2cda2da46cab16cc33f1086f7f1aa163b6c6d6a4e4d2a62103ba9e626704bfc2f275e7e6583cbeab3ee5a9352de48135d214b491caaeae8f550e000d

data/.travis.yml

@@ -8,8 +8,9 @@ rvm:
   - 2.0.0
   - 2.1.10
   - 2.2.8
-  - 2.3.5
-  - 2.4.2
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
   - ruby-head
   - jruby-9.1.1.0
   - jruby-head

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change log
 
+## [v0.8.0] - 2018-04-22
+
+### Added
+* Add :output_only_on_error option by Iulian Onofrei(@revolter)
+* Add :verbose flag to toggle warnings
+
+### Changed
+* Change ProcessRunner to use waitpid2 api for direct status
+* Change ProcessRunner stdout & stderr reading to use IO.select and be non-blocking
+
+### Fixed
+* Fix :timeout to raise when long running without input or output
+* Fix ProcessRunner to ensure no zombie processes on timeouts
+
 ## [v0.7.0] - 2017-11-19
 
 ### Added
@@ -96,6 +110,7 @@
 
 * Initial implementation and release
 
+[v0.8.0]: https://github.com/piotrmurach/tty-command/compare/v0.7.0...v0.8.0
 [v0.7.0]: https://github.com/piotrmurach/tty-command/compare/v0.6.0...v0.7.0
 [v0.6.0]: https://github.com/piotrmurach/tty-command/compare/v0.5.0...v0.6.0
 [v0.5.0]: https://github.com/piotrmurach/tty-command/compare/v0.4.0...v0.5.0

data/README.md

@@ -52,6 +52,8 @@ Or install it yourself as:
   * [2.3. Logging](#23-logging)
     * [2.3.1. Color](#231-color)
     * [2.3.2. UUID](#232-uuid)
+    * [2.3.3. Only output on error](#233-only-output-on-error)
+    * [2.3.4. Verbose](#234-verbose)
   * [2.4. Dry run](#24-dry-run)
   * [2.5. Wait](#25-wait)
   * [2.6. Test](#26-test)
@@ -82,6 +84,8 @@ Or install it yourself as:
 Create a command instance and then run some commands:
 
 ```ruby
+require 'tty-command'
+
 cmd = TTY::Command.new
 cmd.run('ls -la')
 cmd.run('echo Hello!')
@@ -188,18 +192,59 @@ cmd = TTY::Command.new(color: true)
 
 #### 2.3.1 Color
 
-When using printers you can switch off coloring by using `color` option set to `false`.
+When using printers you can switch off coloring by using `:color` option set to `false`.
 
 #### 2.3.2 Uuid
 
-By default when logging is enabled each log entry is prefixed by specific command run uuid number. This number can be switched off using `uuid` option:
+By default, when logging is enabled, each log entry is prefixed by specific command run uuid number. This number can be switched off using the `:uuid` option:
 
 ```ruby
-cmd = TTY::Command.new uuid: false
+cmd = TTY::Command.new(uuid: false)
 cmd.run('rm -R all_my_files')
 # => rm -r all_my_files
 ```
 
+#### 2.3.3 Only output on error
+
+When using a command that can fail, setting `:only_output_on_error` option to `true` hides the output if the command succeeds:
+
+```ruby
+cmd = TTY::Command.new
+cmd.run('non_failing_command', only_output_on_error: true)
+```
+
+This will only print the `Running` and `Finished` lines, while:
+
+```ruby
+cmd.run('non_failing_command')
+```
+
+will also print any output that the `non_failing_command` might generate.
+
+Running either:
+
+```ruby
+cmd.run('failing_command', only_output_on_error: true)
+```
+
+either:
+
+```ruby
+cmd.run('failing_command')
+```
+
+will also print the output.
+
+*Setting this option will cause the output to show at once, at the end of the command.*
+
+#### 2.3.4 Verbose
+
+By default commands will produce warnings when, for example `pty` option is not supported on a given platform. You can switch off such warnings with `:verbose` option set to `false`.
+
+```ruby
+cmd.run("echo '\e[32mColors!\e[0m'", pty: true, verbose: false)
+```
+
 ### 2.4 Dry run
 
 Sometimes it can be useful to put your script into a "dry run" mode that prints commands without actually running them. To simulate execution of the command use the `:dry_run` option:
@@ -394,35 +439,37 @@ cmd.run("whilte test1; sleep1; done", timeout: 5, signal: :KILL)
 
 #### 3.2.6 PTY(pseudo terminal)
 
-The `:pty` configuration option causes the command to be executed in subprocess where each stream is a pseudo terminal. By default this options is set to `false`. However, some comamnds may require a terminal like device to work correctly. For example, a command may emit colored output only if it is running via terminal.
+The `:pty` configuration option causes the command to be executed in subprocess where each stream is a `pseudo terminal`. By default this options is set to `false`.
+
+If you require to interface with interactive subprocess then setting this option to `true` will enable a `pty` terminal device. For example, a command may emit colored output only if it is running via terminal device. You may also wish to run a program that waits for user input, and simulates typing in commands and reading responses.
+
+This option will only work on systems that support BSD pty devices such as Linux or OS X, and it will gracefully fallback to non-pty device on all the other.
 
-In order to run command in pseudo terminal, either set the flag globally for all commands:
+In order to run command in `pseudo terminal`, either set the flag globally for all commands:
 
 ```ruby
 cmd = TTY::Command.new(pty: true)
 ```
 
-or for each executed command individually:
+or individually for each executed command:
 
 ```ruby
 cmd.run("echo 'hello'", pty: true)
 ```
 
-Please note though, that setting `:pty` to `true` may change how the command behaves. For instance, on unix like systems the line feed character `\n` in output will be prefixed with carriage return `\r`:
+Please note that setting `:pty` to `true` may change how the command behaves. It's important to understand the difference between `interactive` and `non-interactive` modes. For example, executing `git log` to view the commit history in default `non-interactive` mode:
 
 ```ruby
-out, _ = cmd.run("echo 'hello'")
-out # => "hello\n"
+cmd.run("git log") # => finishes and produces full output
 ```
 
-and with `:pty` option:
+However, in `interactive` mode with `pty` flag on:
 
 ```ruby
-out, _ = cmd.run("echo 'hello'", pty: true)
-out # => "hello\r\n"
+cmd.run("git log", pty: true) # => uses pager and waits for user input (never returns)
 ```
 
-In addition, any input to command may be echoed to the standard output.
+In addition, when pty device is used, any input to command may be echoed to the standard output, as well as some redirets may not work.
 
 #### 3.2.7 Current directory
 
@@ -588,4 +635,4 @@ The gem is available as open source under the terms of the [MIT License](http://
 
 ## Copyright
 
-Copyright (c) 2016-2017 Piotr Murach. See LICENSE for further details.
+Copyright (c) 2016-2018 Piotr Murach. See LICENSE for further details.

data/appveyor.yml

@@ -19,6 +19,8 @@ environment:
     - ruby_version: "23-x64"
     - ruby_version: "24"
     - ruby_version: "24-x64"
+    - ruby_version: "25"
+    - ruby_version: "25-x64"
 matrix:
   allow_failures:
-    - ruby_version: "193"
+    - ruby_version: "25"

data/examples/env.rb

@@ -4,6 +4,6 @@ require 'tty-command'
 
 cmd = TTY::Command.new
 
-out, err = cmd.run(:echo, "$FOO", env: { foo: 'hello'})
+out, err = cmd.run("env | grep FOO", env: { 'FOO' =>'hello'})
 
 puts "Result: #{out}"

data/examples/redirect_stdin.rb

@@ -1,9 +1,8 @@
 # encoding: utf-8
 
 require 'tty-command'
-require 'pathname'
 
-cli = Pathname.new('examples/cli.rb')
+cli = File.expand_path('cli', __dir__)
 cmd = TTY::Command.new
 
 stdin = StringIO.new

data/lib/tty/command.rb

@@ -59,6 +59,7 @@ module TTY
       @dry_run = options.fetch(:dry_run) { false }
       @printer = use_printer(@printer_name, color: @color, uuid: @uuid)
       @cmd_options = {}
+      @cmd_options[:verbose] = options.fetch(:verbose, true)
       @cmd_options[:pty] = true if options[:pty]
       @cmd_options[:binmode] = true if options[:binmode]
       @cmd_options[:timeout] = options[:timeout] if options[:timeout]
@@ -203,7 +204,7 @@ module TTY
     #
     # @api private
     def find_printer_class(name)
-      const_name = name.to_s.capitalize.to_sym
+      const_name = name.to_s.split('_').map(&:capitalize).join.to_sym
       if const_name.empty? || !TTY::Command::Printers.const_defined?(const_name)
         raise ArgumentError, %(Unknown printer type "#{name}")
       end

data/lib/tty/command/child_process.rb

@@ -25,8 +25,9 @@ module TTY
         process_opts = normalize_redirect_options(cmd.options)
         binmode = cmd.options[:binmode] || false
         pty     = cmd.options[:pty] || false
+        verbose = cmd.options[:verbose]
 
-        pty = try_loading_pty if pty
+        pty = try_loading_pty(verbose) if pty
         require('pty') if pty # load within this scope
 
         # Create pipes
@@ -65,8 +66,8 @@ module TTY
 
         pid = Process.spawn(cmd.to_command, opts)
 
-        # close in parent process
-        [in_rd, out_wr, err_wr].each { |fd| fd.close if fd }
+        # close streams in parent process talking to the child
+        close_fds(in_rd, out_wr, err_wr)
 
         tuple = [pid, in_wr, out_rd, err_rd]
 
@@ -75,7 +76,7 @@ module TTY
             return yield(*tuple)
           ensure
             # ensure parent pipes are closed
-            [in_wr, out_rd, err_rd].each { |fd| fd.close if fd && !fd.closed? }
+            close_fds(in_wr, out_rd, err_rd)
           end
         else
           tuple
@@ -83,16 +84,23 @@ module TTY
       end
       module_function :spawn
 
+      # Close all streams
+      # @api private
+      def close_fds(*fds)
+        fds.each { |fd| fd && !fd.closed? && fd.close }
+      end
+      module_function :close_fds
+
       # Try loading pty module
       #
       # @return [Boolean]
       #
       # @api private
-      def try_loading_pty
+      def try_loading_pty(verbose = false)
         require 'pty'
         true
       rescue LoadError
-        warn("Requested PTY device but the system doesn't support it.")
+        warn("Requested PTY device but the system doesn't support it.") if verbose
         false
       end
       module_function :try_loading_pty

data/lib/tty/command/cmd.rb

@@ -22,6 +22,9 @@ module TTY
       # @api public
       attr_reader :uuid
 
+      # Flag that controls whether to print the output only on error or not
+      attr_reader :only_output_on_error
+
       # Initialize a new Cmd object
       #
       # @api private
@@ -53,6 +56,7 @@ module TTY
         @options = opts
 
         @uuid = SecureRandom.uuid.split('-')[0]
+        @only_output_on_error = opts.fetch(:only_output_on_error) { false }
         freeze
       end
 

data/lib/tty/command/dry_runner.rb

@@ -20,7 +20,7 @@ module TTY
         cmd.to_command
         message = "#{@printer.decorate('(dry run)', :blue)} " +
                   @printer.decorate(cmd.to_command, :yellow, :bold)
-        @printer.write(message, cmd.uuid)
+        @printer.write(cmd, message, cmd.uuid)
         Result.new(0, '', '')
       end
     end # DryRunner

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

@@ -11,6 +11,7 @@ module TTY
         def_delegators :@color, :decorate
 
         attr_reader :output, :options
+        attr_accessor :out_data, :err_data
 
         # Initialize a Printer object
         #
@@ -21,8 +22,11 @@ module TTY
         def initialize(output, options = {})
           @output  = output
           @options = options
-          @enabled  = options.fetch(:color) { true }
+          @enabled = options.fetch(:color) { true }
           @color   = ::Pastel.new(output: output, enabled: @enabled)
+
+          @out_data = ''
+          @err_data = ''
         end
 
         def print_command_start(cmd, *args)
@@ -41,7 +45,7 @@ module TTY
           write(args.join(' '))
         end
 
-        def write(message)
+        def write(cmd, message)
           raise NotImplemented, "Abstract printer cannot be used"
         end
       end # Abstract

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

@@ -14,38 +14,44 @@ module TTY
         def print_command_start(cmd, *args)
           message = ["Running #{decorate(cmd.to_command, :yellow, :bold)}"]
           message << args.map(&:chomp).join(' ') unless args.empty?
-          write(message.join, cmd.uuid)
+          write(cmd, message.join, cmd.uuid)
         end
 
         def print_command_out_data(cmd, *args)
           message = args.map(&:chomp).join(' ')
-          write("\t#{message}", cmd.uuid)
+          write(cmd, "\t#{message}", cmd.uuid, out_data)
         end
 
         def print_command_err_data(cmd, *args)
           message = args.map(&:chomp).join(' ')
-          write("\t" + decorate(message, :red), cmd.uuid)
+          write(cmd, "\t" + decorate(message, :red), cmd.uuid, err_data)
         end
 
         def print_command_exit(cmd, status, runtime, *args)
+          unless !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(message.join, cmd.uuid)
+          write(cmd, message.join, cmd.uuid)
         end
 
         # Write message out to output
         #
         # @api private
-        def write(message, uuid = nil)
+        def write(cmd, message, uuid = nil, data = nil)
           uuid_needed = options.fetch(:uuid) { true }
           out = []
           if uuid_needed
             out << "[#{decorate(uuid, :green)}] " unless uuid.nil?
           end
           out << "#{message}\n"
-          output << out.join
+          target = (cmd.only_output_on_error && !data.nil?) ? data : output
+          target << out.join
         end
 
         private

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

@@ -12,12 +12,26 @@ module TTY
           # quiet
         end
 
-        def print_command_exit(cmd, *args)
+        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(message)
-          output << message
+        def write(cmd, message, data = nil)
+          target = (cmd.only_output_on_error && !data.nil?) ? data : output
+          target << message
         end
       end # Progress
     end # Printers

data/lib/tty/command/process_runner.rb

@@ -23,7 +23,8 @@ module TTY
         @cmd     = cmd
         @timeout = cmd.options[:timeout]
         @input   = cmd.options[:input]
-        @signal  = cmd.options[:signal] || :TERM
+        @signal  = cmd.options[:signal] || "SIGKILL"
+        @binmode = cmd.options[:binmode]
         @printer = printer
         @block   = block
       end
@@ -40,21 +41,19 @@ module TTY
       def run!
         @printer.print_command_start(cmd)
         start = Time.now
-        runtime = 0.0
 
         pid, stdin, stdout, stderr = ChildProcess.spawn(cmd)
 
         # no input to write, close child's stdin pipe
         stdin.close if (@input.nil? || @input.empty?) && !stdin.nil?
 
-        readers = [stdout, stderr]
         writers = [@input && stdin].compact
 
         while writers.any?
-          ready_readers, ready_writers = IO.select(readers, writers, [], @timeout)
-          raise TimeoutExceeded if ready_readers.nil? || ready_writers.nil?
+          ready = IO.select(nil, writers, writers, @timeout)
+          raise TimeoutExceeded if ready.nil?
 
-          write_stream(ready_writers, writers)
+          write_stream(ready[1], writers)
         end
 
         stdout_data, stderr_data = read_streams(stdout, stderr)
@@ -67,6 +66,10 @@ module TTY
         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
@@ -80,6 +83,9 @@ module TTY
 
       private
 
+      # The buffer size for reading stdout and stderr
+      BUFSIZE = 3 * 1024
+
       # @api private
       def handle_timeout(runtime)
         return unless @timeout
@@ -126,13 +132,13 @@ module TTY
         stdout_data = []
         stderr_data = Truncator.new
 
-        out_buffer = -> (line) {
+        out_buffer = ->(line) {
           stdout_data << line
           @printer.print_command_out_data(cmd, line)
           @block.(line, nil) if @block
         }
 
-        err_buffer = -> (line) {
+        err_buffer = ->(line) {
           stderr_data << line
           @printer.print_command_err_data(cmd, line)
           @block.(nil, line) if @block
@@ -144,35 +150,45 @@ module TTY
         stdout_thread.join
         stderr_thread.join
 
-        [stdout_data.join, stderr_data.read]
+        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
           Thread.current[:cmd_start] = Time.now
-          begin
-            while (line = stream.gets)
-              buffer.(line)
-
-              # control total time spent reading
-              runtime = Time.now - Thread.current[:cmd_start]
-              handle_timeout(runtime)
+          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
-          rescue Errno::EIO
-            # GNU/Linux `gets` raises when PTY slave is closed
-            nil
-          rescue => err
-            raise err
-          ensure
-            stream.close
           end
         end
       end
 
       # @api private
       def waitpid(pid)
-        ::Process.waitpid(pid, Process::WUNTRACED)
-        $?.exitstatus
+        _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

data/lib/tty/command/version.rb

@@ -2,6 +2,6 @@
 
 module TTY
   class Command
-    VERSION = '0.7.0'
+    VERSION = '0.8.0'
   end # Command
 end # TTY

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tty-command
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-19 00:00:00.000000000 Z
+date: 2018-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel