seeing_is_believing 3.3.0 → 4.0.1

data/features/xmpfilter-style.feature

@@ -72,6 +72,7 @@ Feature: Xmpfilter style
     #     :wibble=>{:magic_word=>"xyzzy"}}
     """
 
+  @not-2.3
   Scenario: --xmpfilter-style, when displayed on the next line, prints the string across multiple lines
     Given the file "xmpfilter-prev-line-is-multiline-string.rb":
     """

data/lib/seeing_is_believing.rb

@@ -12,6 +12,7 @@ require 'seeing_is_believing/event_stream/handlers/update_result'
 class SeeingIsBelieving
   class Options < HashStruct
     predicate(:event_handler)     { EventStream::Handlers::UpdateResult.new Result.new }
+    predicate(:local_cwd)         { false }
     attribute(:filename)          { nil }
     attribute(:encoding)          { nil }
     attribute(:stdin)             { "" }
@@ -42,15 +43,17 @@ class SeeingIsBelieving
       options.debugger.context("REWRITTEN PROGRAM") { new_program }
 
       EvaluateByMovingFiles.call \
-        new_program,
         filename,
+        @program,
+        new_program,
         event_handler:     event_handler(options.debugger, options.event_handler),
         provided_input:    options.stdin,
         require_files:     options.require_files,
         load_path_dirs:    options.load_path_dirs,
         encoding:          options.encoding,
         timeout_seconds:   options.timeout_seconds,
-        max_line_captures: options.max_line_captures
+        max_line_captures: options.max_line_captures,
+        local_cwd:         options.local_cwd?
 
       options.event_handler
     }

data/lib/seeing_is_believing/binary.rb

@@ -23,7 +23,7 @@ class SeeingIsBelieving
       end
 
       if config.errors.any?
-        stderr.puts *config.errors, *config.deprecations
+        stderr.puts(*config.errors, *config.deprecations)
         return NONDISPLAYABLE_ERROR_STATUS
       end
 
@@ -32,6 +32,11 @@ class SeeingIsBelieving
         return SUCCESS_STATUS
       end
 
+      if config.toggle_mark?
+        stdout.print engine.toggled_mark
+        return SUCCESS_STATUS
+      end
+
       if engine.syntax_error?
         stderr.puts engine.syntax_error
         return NONDISPLAYABLE_ERROR_STATUS

data/lib/seeing_is_believing/binary/annotate_end_of_file.rb

@@ -12,7 +12,7 @@ class SeeingIsBelieving
                  exception_output_for(results, options)
 
         code = Code.new(new_body)
-        code.rewriter.insert_after_multi code.body_range, output
+        code.rewriter.insert_after code.body_range, output
         new_body.replace code.rewriter.process
       end
 

data/lib/seeing_is_believing/binary/annotate_marked_lines.rb

@@ -7,7 +7,7 @@ require 'seeing_is_believing/code'
 
 class SeeingIsBelieving
   module Binary
-    # Based on the behaviour of xmpfilger (a binary in the rcodetools gem)
+    # Based on the behaviour of xmpfilter (a binary in the rcodetools gem)
     # See https://github.com/JoshCheek/seeing_is_believing/issues/44 for more details
     class AnnotateMarkedLines
       def self.map_markers_to_linenos(program, markers)
@@ -46,9 +46,8 @@ class SeeingIsBelieving
           should_pp      = false
           WrapExpressions.call \
             program,
+            before_all: -> { "BEGIN { $SiB.file_loaded };" },
             before_each: -> line_number {
-              # 74 b/c pretty print_defaults to 79 (guessing 80 chars with 1 reserved for newline), and
-              # 79 - "# => ".length # => 4
               inspect        = "$SiB.record_result(:inspect, #{line_number}, ("
               pp             = "$SiB.record_result(:pp, #{line_number}, ("
 
@@ -62,7 +61,11 @@ class SeeingIsBelieving
               end
             },
             after_each:  -> line_number {
-              inspect = "))"
+              # 74 b/c pretty print_defaults to 79 (guessing 80 chars with 1 reserved for newline), and
+              # 79 - "# => ".length # => 4
+              # ALSO: This should be configurable, b/c otherwise you have to go into the guts of `pp`
+              #       https://gist.github.com/JoshCheek/6472c8f334ae493f4ab1f7865e2470e5
+              inspect = ")) { |v| v.inspect }"
               pp      = ")) { |v| PP.pp v, '', 74 }"
 
               should_inspect = inspect_linenos.include? line_number
@@ -111,7 +114,7 @@ class SeeingIsBelieving
             normal_annotation  = annotate_this_line && !pp_annotation
             if exception_result && annotate_this_line
               [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, exception_result, @options)]
-            elsif exception_result
+            elsif exception_result && comment.text.empty?
               whitespace = comment.whitespace
               whitespace = " " if whitespace.empty?
               [whitespace, FormatComment.call(0, exception_prefix, exception_result, @options)]

data/lib/seeing_is_believing/binary/comment_lines.rb

@@ -17,12 +17,12 @@ class SeeingIsBelieving
       def call
         @call ||= begin
           commentable_lines = CommentableLines.new raw_code
-          commentable_lines.call.each do |line_number, (index_of_newline, col)|
+          commentable_lines.call.each do |line_number, (index_of_newline, _col)|
             first_index  = last_index = index_of_newline
             first_index -= 1 while first_index > 0 && raw_code[first_index-1] != "\n"
             comment_text = commenter.call raw_code[first_index...last_index], line_number
             range        = Parser::Source::Range.new(commentable_lines.buffer, first_index, last_index)
-            commentable_lines.rewriter.insert_after_multi range, comment_text
+            commentable_lines.rewriter.insert_after range, comment_text
           end
           commentable_lines.rewriter.process
         end

data/lib/seeing_is_believing/binary/commentable_lines.rb

@@ -54,13 +54,13 @@ class SeeingIsBelieving
       def remove_lines_whose_newline_is_escaped(line_num_to_location)
         ors_indexes = code_obj.indexes_of_ors_at_eol
         line_num_to_location
-          .select { |line_number, (index_of_newline, col)|
+          .select { |line_number, (index_of_newline, _col)|
             code[index_of_newline-1] == '\\'
           }
-          .reject { |line_number, (index_of_newline, col)|
+          .reject { |line_number, (index_of_newline, _col)|
             ors_indexes.include? index_of_newline
           }
-          .each { |line_number, (index_of_newline, col)|
+          .each { |line_number, (_index_of_newline, _col)|
             line_num_to_location.delete line_number
           }
       end
@@ -73,8 +73,8 @@ class SeeingIsBelieving
             begin_pos = comment.location.expression.begin_pos
             end_pos   = comment.location.expression.end_pos
             range     = begin_pos...end_pos
-            line_num_to_location.select { |line_number, (index_of_newline, col)| range.include? index_of_newline }
-                                .each   { |line_number, (index_of_newline, col)| line_num_to_location.delete line_number }
+            line_num_to_location.select { |line_number, (index_of_newline, _col)| range.include? index_of_newline }
+                                .each   { |line_number, (_index_of_newline, _col)| line_num_to_location.delete line_number }
           end
         end
       end
@@ -82,8 +82,8 @@ class SeeingIsBelieving
       def remove_lines_inside_of_strings_and_things(line_num_to_location, ast)
         invalid_boundaries = ranges_of_atomic_expressions ast, []
         invalid_boundaries.each do |invalid_boundary|
-          line_num_to_location.select { |line_number, (index_of_newline, col)| invalid_boundary.include? index_of_newline }
-                              .each   { |line_number, (index_of_newline, col)| line_num_to_location.delete line_number }
+          line_num_to_location.select { |line_number, (index_of_newline, _col)| invalid_boundary.include? index_of_newline }
+                              .each   { |line_number, (_index_of_newline, _col)| line_num_to_location.delete line_number }
         end
       end
 

data/lib/seeing_is_believing/binary/config.rb

@@ -30,6 +30,7 @@ class SeeingIsBelieving
       predicate(:remove_value_prefixes) { true  }
       predicate(:debug)                 { false }
       predicate(:ignore_unknown_flags)  { false }
+      predicate(:toggle_mark)           { nil }
       attribute(:body)                  { nil }
       attribute(:filename)              { nil }
       attribute(:errors)                { [] }
@@ -107,7 +108,11 @@ class SeeingIsBelieving
             self.lib_options.rewrite_code  = AnnotateMarkedLines.code_rewriter(markers)
             self.remove_value_prefixes     = false
             self.lib_options.require_files << 'pp'
-            self.lib_options.require_files << 'seeing_is_believing/customize_pp'
+
+          when '--toggle-mark'
+            extract_positive_int_for.call arg do |n|
+              self.toggle_mark = n
+            end
 
           when '-i', '--inherit-exitstatus', '--inherit-exit-status'
             self.inherit_exitstatus = true
@@ -181,6 +186,9 @@ class SeeingIsBelieving
               as = filename
             end
 
+          when '--local-cwd'
+            self.lib_options.local_cwd = true
+
           when '-s', '--alignment-strategy'
             strategies     = {'file' => AlignFile, 'chunk' => AlignChunk, 'line' => AlignLine}
             strategy_names = strategies.keys.inspect
@@ -249,6 +257,13 @@ class SeeingIsBelieving
         print_event_stream? && (result_as_json? || annotator == AnnotateMarkedLines) &&
           add_error("can only have one output format, --stream is not compatible with --json, -x, and --xmpfilter-style")
 
+        toggle_mark? && print_event_stream? &&
+          add_error("--toggle-mark and --stream are mutually exclusive")
+
+        toggle_mark? && result_as_json? &&
+          add_error("--toggle-mark and --json are mutually exclusive")
+
+
         self.filename                  = filenames.first
         self.lib_options.filename      = as || filename
         self.lib_options.debugger      = debugger
@@ -297,8 +312,7 @@ class SeeingIsBelieving
   end
 
   def Binary.help_screen(markers)
-    value  = markers[:value][:prefix]
-    stdout = markers[:stdout][:prefix]
+    value = markers[:value][:prefix]
 
     <<FLAGS
 Usage: seeing_is_believing [options] [filename]
@@ -326,7 +340,7 @@ Options:
                                    file            =>  the entire file is at the same alignment
                                    line            =>  each line is at its own alignment
        --[no-]-interline-align   # align results on adjacent lines when they have the same number of results
-                                   defautls to --align
+                                   defaults to --align
   -t,  --timeout-seconds s       # how long to evaluate the source file before timing out
                                    0 means it will never timeout (this is the default)
                                    accepts floating point values (e.g. 0.5 would timeout after half a second)
@@ -334,9 +348,12 @@ Options:
   -r,  --require file            # additional files to be required before running the program
   -e,  --program program-body    # pass the program body to execute as an argument
   -a,  --as filename             # run the program as if it was the specified filename
+       --local-cwd               # run the program from the file's directory instead of the calling program's CWD
   -c,  --clean                   # remove annotations from previous runs of seeing_is_believing
   -g,  --debug                   # print debugging information
+       --debug-to FILE           # print debugging information to FILE
   -x,  --xmpfilter-style         # annotate marked lines instead of every line
+       --toggle-mark n           # add / remove annotation on line n
   -j,  --json                    # print results in json format (i.e. so another program can consume them)
   -i,  --inherit-exitstatus      # exit with the exit status of the program being evaluated
        --stream                  # a JSON stream of every event ias it is seen (such as recording a line)

data/lib/seeing_is_believing/binary/engine.rb

@@ -18,12 +18,69 @@ class SeeingIsBelieving
 
       def cleaned_body
         @cleaned_body ||= if missing_newline?
-                            normalized_cleaned_body.chomp!
+                            normalized_cleaned_body.chomp
                           else
                             normalized_cleaned_body
                           end
       end
 
+
+      require 'seeing_is_believing/binary/rewrite_comments'
+      require 'seeing_is_believing/binary/format_comment'
+      module ToggleMark
+        def self.call(options)
+          options = options.dup
+          body    = options.delete :body
+          line    = options.delete :line
+          markers = options.delete :markers
+          alignment_strategy = options.delete :alignment_strategy
+
+          marker_regexes = markers.values.map(&:regex)
+          RewriteComments.call body, include_lines: [line] do |comment|
+            if line == comment.line_number && marker_regexes.any? { |r| r =~ comment.text }
+              new_comment = ''
+            elsif line == comment.line_number && comment.text.empty?
+              new_comment = FormatComment.call(
+                comment.whitespace_col,
+                markers.value.prefix,
+                '',
+                options.merge(
+                  pad_to: alignment_strategy.line_length_for(comment.line_number)
+                ),
+              )
+            elsif line == comment.line_number
+              new_comment = comment.whitespace + comment.text
+            elsif match = markers.value.regex.match(comment.text)
+              new_comment = FormatComment.call(
+                comment.whitespace_col,
+                markers.value.prefix,
+                match.post_match,
+                options.merge(
+                  pad_to: alignment_strategy.line_length_for(comment.line_number)
+                )
+              )
+            else
+              new_comment = comment.whitespace + comment.text
+            end
+            [new_comment[/^\s*/], new_comment.lstrip]
+          end
+        end
+      end
+
+      def toggled_mark
+        body = config.body
+        body         += "\n" if missing_newline?
+        toggled = ToggleMark.call(
+          body:               body,
+          line:               config.toggle_mark,
+          markers:            config.markers,
+          alignment_strategy: config.annotator_options.alignment_strategy.new(normalized_cleaned_body),
+          options:            config.annotator_options.to_h,
+        )
+        toggled.chomp! if missing_newline?
+        toggled
+      end
+
       def syntax_error?
         code.syntax.invalid?
       end

data/lib/seeing_is_believing/binary/format_comment.rb

@@ -1,3 +1,7 @@
+# Polyfill String#scrub on Ruby 2.0.0
+require 'seeing_is_believing/compatibility'
+using SeeingIsBelieving::Compatibility
+
 class SeeingIsBelieving
   module Binary
     # not sure I like this name, it formats comments that show results
@@ -64,12 +68,11 @@ class SeeingIsBelieving
       end
 
       def escape_non_printable(str, omissions)
-        str.each_char
-          .map { |char|
-            next char if 0x20 <= char.ord # above this has a printable representation
-            next char if omissions.include? char
-            char.inspect[1...-1]
-          }.join('')
+        str.scrub { |c| c.inspect[1...-1] }
+           .gsub(/[\u0000-\u0020]/) { |char|
+              next char if omissions.include? char
+              char.inspect[1...-1]
+           }
       end
     end
   end

data/lib/seeing_is_believing/binary/remove_annotations.rb

@@ -76,7 +76,7 @@ class SeeingIsBelieving
             [annotation, comment]
           }
           .slice_before { |annotation, comment| annotation }    # annotations begin chunks
-          .select       { |(annotation, start), *| annotation } # discard chunks not beginning with an annotation (probably can only happens on first comment)
+          .select       { |(annotation, _start), *| annotation } # discard chunks not beginning with an annotation (probably can only happens on first comment)
           .map { |(annotation, start), *rest|                   # end the chunk if the comment doesn't meet nextline criteria
             nextline_comments = []
             prev              = start

data/lib/seeing_is_believing/code.rb

@@ -25,7 +25,7 @@ class SeeingIsBelieving
       @raw             = raw_code
       @buffer          = Parser::Source::Buffer.new(name||"SeeingIsBelieving")
       @buffer.source   = raw
-      @rewriter        = Parser::Source::Rewriter.new buffer
+      @rewriter        = Parser::Source::TreeRewriter.new buffer
       builder          = Parser::Builders::Default.new.tap { |b| b.emit_file_line_as_literals = false }
       @parser          = Parser::CurrentRuby.new builder
       @syntax          = Syntax.new
@@ -91,8 +91,8 @@ class SeeingIsBelieving
     def indexes_of_ors_at_eol
       Set.new(
         @tokens.select { |type, *| type == :tGVAR }
-               .select { |_, (var, range)| var == '$\\'.freeze }
-               .map    { |_, (var, range)| range.end_pos }
+               .select { |_, (var, _range)| var == '$\\'.freeze }
+               .map    { |_, (_var, range)| range.end_pos }
       )
     end
 
@@ -106,10 +106,10 @@ class SeeingIsBelieving
 
     def body_range_from_tokens(tokens)
       return range_for(0, 0) if raw.start_with? "__END__\n"
-      (name, (_, range)) = tokens.max_by { |name, (data, range)| range.end_pos } ||
+      (name, (_, range)) = tokens.max_by { |name, (_data, range)| range.end_pos } ||
                             [nil, [nil, range_for(0, 1)]]
       end_pos = range.end_pos
-      end_pos += 1 if name == :tCOMMENT || name == :tSTRING_END #
+      end_pos += 1 if name == :tCOMMENT || name == :tSTRING_END || name == :tSEMI
       range_for 0, end_pos
     end
 

data/lib/seeing_is_believing/compatibility.rb

@@ -0,0 +1,28 @@
+class SeeingIsBelieving
+  module Compatibility
+  end
+end
+
+# Ruby 2.0.0 is soooooo painful >.<
+# want to stop supporting this so bad!!
+is_v2_0 = !String.instance_methods.include?(:scrub)
+
+is_v2_0 && begin
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  module SeeingIsBelieving::Compatibility
+    refine String do
+      def scrub(char=nil, &block)
+        char && block = lambda { |c| char }
+        each_char.inject("") do |new_str, char|
+          if char.valid_encoding?
+            new_str << char
+          else
+            new_str << block.call(char)
+          end
+        end
+      end
+    end
+  end
+ensure
+  $VERBOSE = old_verbose
+end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -13,12 +13,14 @@
 
 require 'rbconfig'
 require 'socket'
-require 'seeing_is_believing/error'
+require "childprocess"
+
 require 'seeing_is_believing/result'
 require 'seeing_is_believing/debugger'
-require 'seeing_is_believing/hard_core_ensure'
+require 'seeing_is_believing/swap_files'
 require 'seeing_is_believing/event_stream/consumer'
-require "childprocess"
+require 'seeing_is_believing/event_stream/events'
+
 ChildProcess.posix_spawn = true # forking locks up for some reason when we run SiB inside of SiB
 
 class SeeingIsBelieving
@@ -27,69 +29,40 @@ class SeeingIsBelieving
       new(*args).call
     end
 
-    attr_accessor :program, :filename, :provided_input, :require_flags, :load_path_flags, :encoding, :timeout_seconds, :debugger, :event_handler, :max_line_captures
+    attr_accessor :user_program, :rewritten_program, :provided_input, :require_flags, :load_path_flags, :encoding, :timeout_seconds, :debugger, :event_handler, :max_line_captures
 
-    def initialize(program, filename,  options={})
+    attr_accessor :file_directory, :file_path, :local_cwd, :relative_filename, :backup_path
+
+    def initialize(file_path, user_program, rewritten_program, options={})
       options = options.dup
-      self.program           = program
-      self.filename          = filename
+      self.user_program      = user_program
+      self.rewritten_program = rewritten_program
       self.encoding          = options.delete(:encoding)           || "u"
       self.timeout_seconds   = options.delete(:timeout_seconds)    || 0 # 0 is the new infinity
       self.provided_input    = options.delete(:provided_input)     || String.new
       self.event_handler     = options.delete(:event_handler)      || raise(ArgumentError, "must provide an :event_handler")
-      self.load_path_flags   = (options.delete(:load_path_dirs)    || []).map { |dir| ['-I', dir] }.flatten
+      self.load_path_flags   = (options.delete(:load_path_dirs)    || []).flat_map { |dir| ['-I', dir] }
       self.require_flags     = (options.delete(:require_files)     || ['seeing_is_believing/the_matrix']).map { |filename| ['-r', filename] }.flatten
       self.max_line_captures = (options.delete(:max_line_captures) || Float::INFINITY) # (optimization: child stops producing results at this number, even though it might make more sense for the consumer to stop emitting them)
+      self.local_cwd         = options.delete(:local_cwd)          || false
+      self.file_path         = file_path
+      self.file_directory    = File.dirname file_path
+      file_name              = File.basename file_path
+      self.relative_filename = local_cwd ? file_name : file_path
+      self.backup_path       = File.join file_directory, "seeing_is_believing_backup.#{file_name}"
+
       options.any? && raise(ArgumentError, "Unknown options: #{options.inspect}")
     end
 
     def call
-      HardCoreEnsure.call \
-        code: -> {
-          we_will_not_overwrite_existing_backup_file!
-          backup_existing_file
-          write_program_to_file
-          evaluate_file
-        },
-        ensure: -> {
-          set_back_to_initial_conditions
-        }
-    end
-
-    def file_directory
-      File.dirname filename
-    end
-
-    def backup_filename
-      File.join file_directory, "seeing_is_believing_backup.#{File.basename filename}"
-    end
-
-    private
-
-    def we_will_not_overwrite_existing_backup_file!
-      raise TempFileAlreadyExists.new(filename, backup_filename) if File.exist? backup_filename
-    end
-
-    def backup_existing_file
-      return unless File.exist? filename
-      File.rename filename, backup_filename
-      @was_backed_up = true
-    end
-
-    def set_back_to_initial_conditions
-      if @was_backed_up
-        File.rename(backup_filename, filename)
-      else
-        File.delete(filename)
+      SwapFiles.call file_path, backup_path, user_program, rewritten_program do |swap_files|
+        evaluate_file swap_files
       end
     end
 
-    def write_program_to_file
-      File.open(filename, 'w', external_encoding: "utf-8") { |f| f.write program.to_s }
-    end
-
+    private
 
-    def evaluate_file
+    def evaluate_file(swap_files)
       event_server = TCPServer.new(0) # dynamically allocates an available port
 
       # setup streams
@@ -101,11 +74,12 @@ class SeeingIsBelieving
                                 [Marshal.dump(
                                   event_stream_port: event_server.addr[1],
                                   max_line_captures: max_line_captures,
-                                  num_lines:         program.lines.count,
-                                  filename:          filename
+                                  num_lines:         user_program.lines.count,
+                                  filename:          relative_filename,
                                 )].pack('m0')
 
       child = ChildProcess.build(*popen_args)
+      child.cwd    = file_directory if local_cwd
       child.leader = true
       child.duplex = true
       child.environment.merge!(env)
@@ -124,13 +98,23 @@ class SeeingIsBelieving
 
       # send stdin (char at a time b/c input could come from a stream)
       Thread.new do
-        provided_input.each_char { |char| child.io.stdin.write char }
-        child.io.stdin.close
+        begin
+          provided_input.each_char { |char| child.io.stdin.write char }
+        rescue
+          # don't explode if child closes IO
+        ensure
+          child.io.stdin.close
+        end
       end
 
       # set up the event consumer
       consumer = EventStream::Consumer.new(events: eventstream, stdout: stdout, stderr: stderr)
-      consumer_thread = Thread.new { consumer.each { |e| event_handler.call e } }
+      consumer_thread = Thread.new do
+        consumer.each do |e|
+          swap_files.show_user_program if e.is_a? SeeingIsBelieving::EventStream::Events::FileLoaded
+          event_handler.call e
+        end
+      end
 
       # wait for completion
       if timeout_seconds == 0
@@ -148,13 +132,19 @@ class SeeingIsBelieving
       # On Windows, we need to call stop if there is an error since it interrupted
       # the previos waiting/polling. If we don't call stop, in that situation, it will
       # leave orphan processes. On Unix, we need to always call stop or it may leave orphans
-      if ChildProcess.unix?
-        child.stop
-      elsif $!
-        child.stop
-        consumer.process_exitstatus(child.exit_code)
+      begin
+        if ChildProcess.unix?
+          child.stop
+        elsif $!
+          child.stop
+          consumer.process_exitstatus(child.exit_code)
+        end
+        child.alive? && child.stop
+      rescue ChildProcess::Error
+        # On AppVeyor, I keep getting errors
+        #   The handle is invalid: https://ci.appveyor.com/project/JoshCheek/seeing-is-believing/build/22
+        #   Access is denied:      https://ci.appveyor.com/project/JoshCheek/seeing-is-believing/build/24
       end
-      cleanup_run(child)
       close_streams(stdout, stderr, eventstream, event_server)
     end
 
@@ -165,20 +155,11 @@ class SeeingIsBelieving
          '-I', File.realpath('..', __dir__),        # add lib to the load path
          *load_path_flags,                          # users can inject dirs to be added to the load path
          *require_flags,                            # users can inject files to be required
-         filename]
+         relative_filename]
     end
 
     def close_streams(*streams)
       streams.each { |io| io.close unless io.closed? }
     end
-
-    # On AppVeyor, I keep getting errors
-    #   The handle is invalid: https://ci.appveyor.com/project/JoshCheek/seeing-is-believing/build/22
-    #   Access is denied:      https://ci.appveyor.com/project/JoshCheek/seeing-is-believing/build/24
-    def cleanup_run(child, *streams)
-      child.alive? && child.stop
-    rescue ChildProcess::Error
-      # noop
-    end
   end
 end