tty-command 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 234c1a25407b1be27c06441a1d1d9ec6cce50593
-  data.tar.gz: bd9ff0177f553972aede0ce9ef718b4731fb587d
+  metadata.gz: b9086c13127af2f7d61b0577426a34ea6e71929c
+  data.tar.gz: fbb089e7cc7d6937571ab84c3700856bb6f7eac7
 SHA512:
-  metadata.gz: bddbfb2794b1c672147162e28e3b380bec7e3c1b511b46dee46c688d994b7735cebba6db865dddb89dd6dfffec3de8ffa672f1e15bdcde01292805f240072926
-  data.tar.gz: aa19370eb59f7127bb8ffa3bf64e4a97f6be2c9abc88143b3a1818cd0100baa0457b5031d63186e05d0a571a41283d4c7964378d38f13cc155c6d1c25d5ed499
+  metadata.gz: 3eeb7cc3fc245a9bc126ee2948c9d02ebae2e88df4f83a4c3ead72e4ee8b1597ac087b039448f843ab4f305575957dbde65f86ff7813101678a801aabc3f37a3
+  data.tar.gz: 028e2be35a74088e0015bb60577a4cbdf462b31e727221aa7e3d72a7c2530c68f47bdff8ed1593e55d1af249f1e006d6078d15d55dbbc59d839fc35a5fac4a6b

data/.rspec

@@ -1,3 +1,4 @@
 --require spec_helper
 --color
+--format doc
 --warnings

data/.travis.yml

@@ -8,7 +8,7 @@ rvm:
   - 2.1.10
   - 2.2.6
   - 2.3.3
-  - 2.4.0
+  - 2.4.1
   - ruby-head
   - jruby-9.1.1.0
   - jruby-head

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Change log
 
+## [v0.5.0] - 2017-07-16
+
+### Added
+* Add :signal option for timeout
+* Add :input option for handling stdin input
+* Add ability for Command#run to specify a callback that is invoked whenever stdout or stderr receive output
+* Add Command#wait for polling a long running script for matching output
+
+### Changed
+* Change ProcessRunner to immediately sync write pipe
+* Change ProcessRunner to write to stdin stream when writable
+
+### Fixed
+* Fix quiet printer write call by @jamesepatrick
+* Fix to correctly close all pipe ends between parent and child process
+* Fix timeout behaviour for writable and readable streams
+
 ## [v0.4.0] - 2017-02-22
 
 ### Changed

data/README.md

@@ -46,20 +46,24 @@ Or install it yourself as:
 * [2. Interface](#2-interface)
   * [2.1. Run](#21-run)
   * [2.2. Run!](#22-run)
-  * [2.3. Test](#23-test)
-  * [2.4. Logging](#24-logging)
-  * [2.5. Dry run](#25-dry-run)
-  * [2.6. Ruby interpreter](#26-ruby-interpreter)
+  * [2.3. Logging](#23-logging)
+    * [2.3.1. Color](#231-color)
+    * [2.3.2. UUID](#232-uuid)
+  * [2.4. Dry run](#24-dry-run)
+  * [2.5. Wait](#25-wait)
+  * [2.6. Test](#26-test)
+  * [2.7. Ruby interpreter](#27-ruby-interpreter)
 * [3. Advanced Interface](#3-advanced-interface)
   * [3.1. Environment variables](#31-environment-variables)
   * [3.2. Options](#32-options)
     * [3.2.1. Current directory](#321-current-directory)
     * [3.2.2. Redirection](#322-redirection)
-    * [3.2.3. Handling input](#323-handling-input)    
-    * [3.2.4. Timeout](#324-timeout)    
-    * [3.2.5. User](#324-user)
-    * [3.2.6. Group](#325-group)
-    * [3.2.7. Umask](#326-umask)
+    * [3.2.3. Handling input](#323-handling-input)
+    * [3.2.4. Timeout](#324-timeout)
+    * [3.2.5. Signal](#325-signal)
+    * [3.2.6. User](#326-user)
+    * [3.2.7. Group](#327-group)
+    * [3.2.8. Umask](#328-umask)
   * [3.3. Result](#33-result)
     * [3.3.1. success?](#331-success)
     * [3.3.2. failure?](#332-failure)
@@ -121,6 +125,15 @@ puts "The date is #{out}"
 # => "The date is Tue 10 May 2016 22:30:15 BST\n"
 ```
 
+You can also pass a block that gets invoked anytime stdout and/or stderr receive output:
+
+```ruby
+cmd.run('long running script') do |out, err|
+  output << out if out
+  errors << err if err
+end
+```
+
 If the command fails (with a non-zero exit code), a `TTY::Command::ExitError` is raised. The `ExitError` message will include:
 
   * the name of command executed
@@ -140,20 +153,7 @@ if cmd.run!('which xyzzy').failure?
 end
 ```
 
-### 2.3 Test
-
-To simulate classic bash test command you case use `test` method with expression to check as a first argument:
-
-```ruby
-if cmd.test '-e /etc/passwd'
-  puts "Sweet..."
-else
-  puts "Ohh no! Where is it?"
-  exit 1
-end
-```
-
-### 2.4 Logging
+### 2.3 Logging
 
 By default, when a command is run, the command and the output are printed to `stdout` using the `:pretty` printer. If you wish to change printer you can do so by passing a `:printer` option:
 
@@ -172,7 +172,7 @@ By default the printers log to `stdout` but this can be changed by passing an ob
 
 ```ruby
 logger = Logger.new('dev.log')
-cmd = TTY::Command.new(output: output)
+cmd = TTY::Command.new(output: logger)
 ```
 
 You can force the printer to always in print in color by passing the `:color` option:
@@ -181,7 +181,21 @@ You can force the printer to always in print in color by passing the `:color` op
 cmd = TTY::Command.new(color: true)
 ```
 
-### 2.5 Dry run
+#### 2.3.1 Color
+
+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:
+
+```ruby
+cmd = TTY::Command.new uuid: false
+cmd.run('rm -R all_my_files')
+# => rm -r all_my_files
+```
+
+### 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:
 
@@ -197,7 +211,28 @@ To check what mode the command is in use the `dry_run?` query helper:
 cmd.dry_run? # => true
 ```
 
-### 2.6 Ruby interpreter
+### 2.5 Wait
+
+If you need to wait for a long running script and stop it when a given pattern has been matched use `wait` like so:
+
+```ruby
+cmd.wait 'tail -f /var/log/production.log', /something happened/
+```
+
+### 2.6 Test
+
+To simulate classic bash test command you case use `test` method with expression to check as a first argument:
+
+```ruby
+if cmd.test '-e /etc/passwd'
+  puts "Sweet..."
+else
+  puts "Ohh no! Where is it?"
+  exit 1
+end
+```
+
+### 2.7 Ruby interpreter
 
 In order to run a command with Ruby interpreter do:
 
@@ -274,7 +309,21 @@ cmd.run(:ls, '-la', 2 => 1)
 
 #### 3.2.3 Handling Input
 
-You can pass input via the :in option, by passing a StringIO Object. This object might have more than one line, if the executed command reads more than once from STDIN.
+You can provide input to stdin stream using the `:input` key. For instance, given the following executable called `cli` that expects name from `stdin`:
+
+```ruby
+name = $stdin.gets
+puts "Your name: #{name}"
+```
+
+In order to execute `cli` with name input do:
+
+```ruby
+cmd.run('cli', input: "Piotr\n")
+# => Your name: Piotr
+```
+
+Alternatively, you can pass input via the :in option, by passing a `StringIO` Object. This object might have more than one line, if the executed command reads more than once from STDIN.
 
 Assume you have run a program, that first asks for your email address and then for a password:
 
@@ -284,7 +333,7 @@ in_stream.puts "username@example.com"
 in_stream.puts "password"
 in_stream.rewind
 
-TTY::Command.new.run("my_cli_program", "login", in: in_stream).out
+cmd.run("my_cli_program", "login", in: in_stream).out
 ```
 
 #### 3.2.4 Timeout
@@ -297,7 +346,15 @@ cmd.run("while test 1; sleep 1; done", timeout: 5)
 
 Please run `examples/timeout.rb` to see timeout in action.
 
-#### 3.2.5 User
+#### 3.2.5 Signal
+
+You can specify process termination signal other than the defaut `SIGTERM`:
+
+```ruby
+cmd.run("whilte test1; sleep1; done", timeout: 5, signal: :KILL)
+```
+
+#### 3.2.6 User
 
 To run command as a given user do:
 
@@ -305,7 +362,7 @@ To run command as a given user do:
 cmd.run(:echo, 'hello', user: 'piotr')
 ```
 
-#### 3.2.6 Group
+#### 3.2.7 Group
 
 To run command as part of group do:
 
@@ -313,7 +370,7 @@ To run command as part of group do:
 cmd.run(:echo, 'hello', group: 'devs')
 ```
 
-#### 3.2.7 Umask
+#### 3.2.8 Umask
 
 To run command with umask do:
 

data/examples/basic.rb

@@ -4,6 +4,6 @@ require 'tty-command'
 
 cmd = TTY::Command.new
 
-out, err = cmd.execute(:echo, 'hello world!')
+out, err = cmd.run(:echo, 'hello world!')
 
 puts "Result: #{out}"

data/examples/cli

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+name = $stdin.gets
+puts "Your name: #{name}"

data/examples/output.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'tty-command'
+
+cmd = TTY::Command.new
+cmd.run("i=0; while true; do i=$[$i+1]; echo 'hello '$i; sleep 1; done") do |out, err|
+  if out =~ /.*5.*/
+    raise ArgumentError, 'BOOM'
+  end
+end

data/examples/redirect_stdin.rb

@@ -1,7 +1,9 @@
 # encoding: utf-8
 
 require 'tty-command'
+require 'pathname'
 
+cli = Pathname.new('examples/cli.rb')
 cmd = TTY::Command.new
 
 stdin = StringIO.new
@@ -9,6 +11,6 @@ stdin.puts "hello"
 stdin.puts "world"
 stdin.rewind
 
-out, _ = cmd.run(:cat, :in => stdin)
+out, _ = cmd.run(cli, :in => stdin)
 
 puts "#{out}"

data/examples/stdin_input.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'tty-command'
+require 'pathname'
+
+cmd = TTY::Command.new
+cli = Pathname.new('examples/cli')
+out, _ = cmd.run(cli, input: "Piotr\n")
+
+puts "#{out}"

data/examples/timeout.rb

@@ -4,4 +4,4 @@ require 'tty-command'
 
 cmd = TTY::Command.new
 
-cmd.run("while test 1; do echo 'hello'; sleep 1; done", timeout: 5)
+cmd.run("while test 1; do echo 'hello'; sleep 1; done", timeout: 5, signal: :KILL)

data/examples/wait.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'tty-command'
+require 'logger'
+
+logger = Logger.new('dev.log')
+cmd = TTY::Command.new
+
+Thread.new do
+  10.times do |i|
+    sleep 1
+    if i == 5
+      logger << "error\n"
+    else
+      logger << "hello #{i}\n"
+    end
+  end
+end
+
+
+cmd.wait('tail -f dev.log', /error/)

data/lib/tty/command.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 require 'rbconfig'
-require 'tty/command/version'
 
 require_relative 'command/cmd'
 require_relative 'command/exit_error'
@@ -11,6 +10,7 @@ require_relative 'command/printers/null'
 require_relative 'command/printers/pretty'
 require_relative 'command/printers/progress'
 require_relative 'command/printers/quiet'
+require_relative 'command/version'
 
 module TTY
   class Command
@@ -21,7 +21,8 @@ module TTY
     # Path to the current Ruby
     RUBY = ENV['RUBY'] || ::File.join(
       RbConfig::CONFIG['bindir'],
-      RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT'])
+      RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']
+    )
 
     def self.record_separator
       @record_separator ||= $/
@@ -71,23 +72,25 @@ module TTY
     #
     # @param [Hash] options
     #   hash of operations to perform
-    #
     # @option options [String] :chdir
     #   The current directory.
-    #
     # @option options [Integer] :timeout
     #   Maximum number of seconds to allow the process
     #   to run before aborting with a TimeoutExceeded
     #   exception.
+    # @option options [Symbol] :signal
+    #   Signal used on timeout, SIGKILL by default
+    #
+    # @yield [out, err]
+    #   Yields stdout and stderr output whenever available
     #
     # @raise [ExitError]
     #   raised when command exits with non-zero code
     #
     # @api public
-    def run(*args)
+    def run(*args, &block)
       cmd = command(*args)
-      yield(cmd) if block_given?
-      result = execute_command(cmd)
+      result = execute_command(cmd, &block)
       if result && result.failure?
         raise ExitError.new(cmd.to_command, result)
       end
@@ -100,10 +103,28 @@ module TTY
     #   cmd.run!(command, [argv1, ..., argvN], [options])
     #
     # @api public
-    def run!(*args)
+    def run!(*args, &block)
       cmd = command(*args)
-      yield(cmd) if block_given?
-      execute_command(cmd)
+      execute_command(cmd, &block)
+    end
+
+    # Wait on long running script until output matches a specific pattern
+    #
+    # @example
+    #   cmd.wait 'tail -f /var/log/php.log', /something happened/
+    #
+    # @api public
+    def wait(*args)
+      pattern = args.pop
+      unless pattern
+        raise ArgumentError, 'Please provide condition to wait for'
+      end
+
+      run(*args) do |out, _|
+        raise if out =~ /#{pattern}/
+      end
+    rescue ExitError
+      # noop
     end
 
     # Execute shell test command
@@ -145,11 +166,11 @@ module TTY
     end
 
     # @api private
-    def execute_command(cmd)
+    def execute_command(cmd, &block)
       mutex = Mutex.new
       dry_run = @dry_run || cmd.options[:dry_run] || false
-      @runner = select_runner(@printer, dry_run)
-      mutex.synchronize { @runner.run(cmd) }
+      @runner = select_runner(dry_run).new(cmd, @printer)
+      mutex.synchronize { @runner.run!(&block) }
     end
 
     # @api private
@@ -173,17 +194,17 @@ module TTY
     def find_printer_class(name)
       const_name = name.to_s.capitalize.to_sym
       if const_name.empty? || !TTY::Command::Printers.const_defined?(const_name)
-        fail ArgumentError, %(Unknown printer type "#{name}")
+        raise ArgumentError, %(Unknown printer type "#{name}")
       end
       TTY::Command::Printers.const_get(const_name)
     end
 
     # @api private
-    def select_runner(printer, dry_run)
+    def select_runner(dry_run)
       if dry_run
-        DryRunner.new(printer)
+        DryRunner
       else
-        ProcessRunner.new(printer)
+        ProcessRunner
       end
     end
   end # Command

data/lib/tty/command/dry_runner.rb

@@ -5,11 +5,17 @@ require_relative 'result'
 module TTY
   class Command
     class DryRunner
-      def initialize(printer)
+      attr_reader :cmd
+
+      def initialize(cmd, printer)
+        @cmd     = cmd
         @printer = printer
       end
 
-      def run(cmd)
+      # Show command without running
+      #
+      # @api public
+      def run!(&block)
         cmd.to_command
         message = "#{@printer.decorate('(dry run)', :blue)} "
         message << @printer.decorate(cmd.to_command, :yellow, :bold)

data/lib/tty/command/execute.rb

@@ -6,37 +6,39 @@ require 'securerandom'
 module TTY
   class Command
     module Execute
-      # Execute command in a child process
+      # Execute command in a child process with all IO streams piped
+      # in and out. The interface is similar to Process.spawn
       #
       # The caller should ensure that all IO objects are closed
       # when the child process is finished. However, when block
       # is provided this will be taken care of automatically.
       #
       # @param [Cmd] cmd
-      #   the command to execute
+      #   the command to spawn
       #
       # @return [pid, stdin, stdout, stderr]
       #
       # @api public
       def spawn(cmd)
-        @process_options = normalize_redirect_options(cmd.options)
+        process_opts = normalize_redirect_options(cmd.options)
 
         # Create pipes
         in_rd,  in_wr  = IO.pipe # reading
         out_rd, out_wr = IO.pipe # writing
         err_rd, err_wr = IO.pipe # error
+        in_wr.sync = true
 
         # redirect fds
         opts = ({
-          :in  => in_rd, # in_wr  => :close,
-          :out => out_wr,# out_rd => :close,
-          :err => err_wr,# err_rd => :close
-        }).merge(@process_options)
+          :in  => in_rd,  in_wr  => :close,
+          :out => out_wr, out_rd => :close,
+          :err => err_wr, err_rd => :close
+        }).merge(process_opts)
 
         pid = Process.spawn(cmd.to_command, opts)
 
         # close in parent process
-        [out_wr, err_wr].each { |fd| fd.close if fd }
+        [in_rd, out_wr, err_wr].each { |fd| fd.close if fd }
 
         tuple = [pid, in_wr, out_rd, err_rd]
 

data/lib/tty/command/exit_error.rb

@@ -20,8 +20,8 @@ module TTY
         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"
+        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

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

@@ -17,7 +17,7 @@ module TTY
         end
 
         def write(message)
-          output.print(message)
+          output << message
         end
       end # Progress
     end # Printers

data/lib/tty/command/process_runner.rb

@@ -11,84 +11,150 @@ module TTY
     class ProcessRunner
       include Execute
 
+      # 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(printer)
+      def initialize(cmd, printer)
+        @cmd     = cmd
+        @timeout = cmd.options[:timeout]
+        @input   = cmd.options[:input]
+        @signal  = cmd.options[:signal] || :TERM
         @printer = printer
+        @threads = []
+        @lock    = Mutex.new
       end
 
       # Execute child process
       # @api public
-      def run(cmd)
-        timeout = cmd.options[:timeout]
+      def run!(&block)
         @printer.print_command_start(cmd)
         start = Time.now
+        runtime = 0.0
 
-        spawn(cmd) do |pid, stdin, stdout, stderr|
-          stdout_data, stderr_data = read_streams(cmd, stdout, stderr)
+        pid, stdin, stdout, stderr = spawn(cmd) # do |pid, stdin, stdout, stderr|
 
-          runtime = Time.now - start
-          handle_timeout(timeout, runtime, pid)
-          status = waitpid(pid)
+        # write and read streams
+        write_stream(stdin)
+        stdout_data, stderr_data = read_streams(stdout, stderr, &block)
 
-          @printer.print_command_exit(cmd, status, runtime)
+        status = waitpid(pid)
+        runtime = Time.now - start
 
-          Result.new(status, stdout_data, stderr_data)
-        end
+        @printer.print_command_exit(cmd, status, runtime)
+
+        Result.new(status, stdout_data, stderr_data)
+      rescue
+        terminate(pid)
+        Result.new(-1, stdout_data, stderr_data)
+      ensure
+        [stdin, stdout, stderr].each { |fd| fd.close if fd && !fd.closed? }
+      end
+
+      # Stop a process marked by pid
+      #
+      # @param [Integer] pid
+      #
+      # @api public
+      def terminate(pid)
+        ::Process.kill(@signal, pid)
       end
 
       private
 
       # @api private
-      def handle_timeout(timeout, runtime, pid)
-        return unless timeout
+      def handle_timeout(runtime)
+        return unless @timeout
 
-        t = timeout - runtime
-        if t < 0.0
-          ::Process.kill(:KILL, pid)
+        t = @timeout - runtime
+        raise TimeoutExceeded if t < 0.0
+      end
+
+      # @api private
+      def write_stream(stdin)
+        return unless @input
+        writers = [stdin]
+        start = Time.now
+
+        # wait when ready for writing to pipe
+        _, writable = IO.select(nil, writers, writers, @timeout)
+        raise TimeoutExceeded if writable.nil?
+
+        while writers.any?
+          writable.each do |fd|
+            begin
+              err   = nil
+              size  = fd.write(@input)
+              @input = @input.byteslice(size..-1)
+            rescue Errno::EPIPE => err
+            end
+            if err || @input.bytesize == 0
+              writers.delete(stdin)
+            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(cmd, stdout, stderr)
+      def read_streams(stdout, stderr, &block)
         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
+        print_out = -> (cmd, line) { @printer.print_command_out_data(cmd, line) }
+        print_err = -> (cmd, line) { @printer.print_command_err_data(cmd, line) }
+
+        stdout_yield = -> (line) { block.(line, nil) if block }
+        stderr_yield = -> (line) { block.(nil, line) if block }
+
+        @threads << read_stream(stdout, stdout_data, print_out, stdout_yield)
+        @threads << read_stream(stderr, stderr_data, print_err, stderr_yield)
+
+        @threads.each do |th|
+          result = th.join(@timeout)
+          if result.nil?
+            @threads[0].raise
+            @threads[1].raise
           end
         end
 
-        stderr_thread = Thread.new do
+        [stdout_data, stderr_data.read]
+      end
+
+      def read_stream(stream, data, print_callback, callback)
+        Thread.new do
+          Thread.current[:cmd_start] = Time.now
           begin
-            while (line = stderr.gets)
-              stderr_data << line
-              @printer.print_command_err_data(cmd, line)
+            while (line = stream.gets)
+              @lock.synchronize do
+                data << line
+                callback.(line)
+                print_callback.(cmd, line)
+              end
+
+              # control total time spent reading
+              runtime = Time.now - Thread.current[:cmd_start]
+              handle_timeout(runtime)
             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)
+          rescue => err
+            raise err
+          ensure
+            stream.close
           end
         end
-        [stdout_data, stderr_data.read]
       end
 
       # @api private

data/lib/tty/command/version.rb

@@ -2,6 +2,6 @@
 
 module TTY
   class Command
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end # Command
 end # TTY

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tty-command
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-22 00:00:00.000000000 Z
+date: 2017-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel
@@ -94,12 +94,16 @@ files:
 - bin/setup
 - examples/bash.rb
 - examples/basic.rb
+- examples/cli
 - examples/env.rb
 - examples/logger.rb
+- examples/output.rb
 - examples/redirect_stderr.rb
 - examples/redirect_stdin.rb
 - examples/redirect_stdout.rb
+- examples/stdin_input.rb
 - examples/timeout.rb
+- examples/wait.rb
 - lib/tty-command.rb
 - lib/tty/command.rb
 - lib/tty/command/cmd.rb