seeing_is_believing 3.1.1 → 3.2.0

data/features/regression.feature

@@ -240,7 +240,7 @@ Feature:
 
 
   Scenario: Repeated invocations
-    When I run "echo 'puts 1' | seeing_is_believing | seeing_is_believing"
+    When I run the pipeline "echo puts 1" | "seeing_is_believing" | "seeing_is_believing"
     Then stdout is:
     """
     puts 1  # => nil
@@ -322,9 +322,10 @@ Feature:
   Scenario: A program overriding stdout/stderr
     Given the file "black_hole.rb":
     """
-    File.open '/dev/null', 'w' do |black_hole|
-      STDERR = $stderr = black_hole
-      STDOUT = $stdout = black_hole
+    require 'rubygems'
+    File.open IO::NULL, 'w' do |black_hole|
+      STDERR = $stderr = black_hole; nil
+      STDOUT = $stdout = black_hole; nil
       puts "You won't see this, it goes into the black hole"
       system %q(ruby -e '$stdout.puts "stdout gets past it b/c of dumb ruby bug"')
       system %q(ruby -e '$stderr.puts "stderr gets past it b/c of dumb ruby bug"')
@@ -335,9 +336,10 @@ Feature:
     And the exit status is 0
     And stdout is:
     """
-    File.open '/dev/null', 'w' do |black_hole|                                      # => File
-      STDERR = $stderr = black_hole                                                 # => #<File:/dev/null>
-      STDOUT = $stdout = black_hole                                                 # => #<File:/dev/null>
+    require 'rubygems'                                                              # => false
+    File.open IO::NULL, 'w' do |black_hole|                                         # => File
+      STDERR = $stderr = black_hole; nil                                            # => nil
+      STDOUT = $stdout = black_hole; nil                                            # => nil
       puts "You won't see this, it goes into the black hole"                        # => nil
       system %q(ruby -e '$stdout.puts "stdout gets past it b/c of dumb ruby bug"')  # => true
       system %q(ruby -e '$stderr.puts "stderr gets past it b/c of dumb ruby bug"')  # => true
@@ -420,7 +422,7 @@ Feature:
     And stdout includes "zomg"
 
 
-  Scenario: Comments with makers elsewhere in them
+  Scenario: Comments with markers elsewhere in them
     Given the file "comments_with_markers_elsewhere.rb":
     """
     # a # => a
@@ -463,9 +465,13 @@ Feature:
     """
 
 
-  # not going to get too detailed on what it prints, b/c that message seems pretty fragile,
+  # See this issue for the issue we're testing for: https://github.com/JoshCheek/seeing_is_believing/issues/46
+  # See this issue for why we turn it off on 2.4: https://github.com/flori/json/issues/309
+  #
+  # Not going to get too detailed on what it prints, b/c that message seems pretty fragile,
   # but just generally that it doesn't fkn blow up
-  Scenario: https://github.com/JoshCheek/seeing_is_believing/issues/46
+  @not-2.4.0
+  Scenario: Old JSON bug
     Given the file "json_and_encodings.rb":
     """
     # encoding: utf-8
@@ -482,6 +488,27 @@ Feature:
     """
 
 
+  # https://github.com/JoshCheek/seeing_is_believing/wiki/Encodings
+  # https://github.com/JoshCheek/seeing_is_believing/issues/109
+  Scenario: Assumes utf-8 for files regardless of what Ruby thinks
+    Given the environment variable "LANG" is set to ''
+    And the file "utf8_file_without_magic_comment.rb" "縧 = 1"
+    When I run "seeing_is_believing utf8_file_without_magic_comment.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is "縧 = 1  # => 1"
+
+
+  # https://github.com/JoshCheek/seeing_is_believing/issues/109
+  Scenario: Assumes utf-8 for files regardless of what Ruby thinks
+    Given the environment variable "LANG" is set to ''
+    Given the stdin content "縧 = 1"
+    When I run "seeing_is_believing utf8_file_without_magic_comment.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is "縧 = 1  # => 1"
+
+
   Scenario: Correctly identify end of file
     Given the file "fake_data_segment.rb":
     """
@@ -656,3 +683,73 @@ Feature:
     And  stdout includes 'Zomg                       # => lolol'
     And  stdout includes '# ~> ZeroDivisionError'
     And  stdout includes '# ~> divided by 0'
+
+
+  Scenario: All objects have an object id (Issue #91)
+    Given the file "object_ids.rb":
+    """
+    ObjectSpace.each_object { |o| o.object_id || p(obj: o) }#
+    """
+    When I run "seeing_is_believing object_ids.rb"
+    Then stderr is empty
+    And stdout is:
+    """
+    ObjectSpace.each_object { |o| o.object_id || p(obj: o) }#
+    """
+
+
+  Scenario: Does not blow up when the program closes its stdin/stdout/stderr
+    Given the stdin content "input"
+    And the file "closed_pipes.rb":
+    """
+    [$stdin, $stdout, $stderr].each &:close#
+    """
+    When I run "seeing_is_believing closed_pipes.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    [$stdin, $stdout, $stderr].each &:close#
+    """
+
+
+  Scenario: Overriding Symbol#inspect
+    Given the file "overriding_symbol_inspect.rb":
+    """
+    :abc # =>
+    class Symbol
+      def inspect
+        "overridden"
+      end
+    end
+    :abc # =>
+    """
+    When I run "seeing_is_believing overriding_symbol_inspect.rb -x"
+    Then stderr is empty
+    And the exit status is 0
+    Then stdout is:
+    """
+    :abc # => :abc
+    class Symbol
+      def inspect
+        "overridden"
+      end
+    end
+    :abc # => overridden
+    """
+
+
+  Scenario: SiB running SiB
+    Given the file "sib_running_sib.rb":
+    """
+    require 'seeing_is_believing'
+    SeeingIsBelieving.call("1+1").result[1][0]
+    """
+    When I run "seeing_is_believing sib_running_sib.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    require 'seeing_is_believing'               # => true
+    SeeingIsBelieving.call("1+1").result[1][0]  # => "2"
+    """

data/features/support/env.rb

@@ -1,6 +1,49 @@
 require_relative '../../lib/seeing_is_believing/version'
 
 require 'haiti'
+# A lot of the stuff in this file should get moved into haiti
+
+module Haiti
+  module CommandLineHelpers
+    # overwriting this method while trying to get windows support working,
+    # it looks like the underlying shell is treating the commands differently
+    # probably on Unix it invoked `sh` and did shady shit with splitting a string into an array on whitespace
+    # and on Windows (powershell?) it expected an actual array of strings
+    require 'shellwords'
+    def execute(command_string, stdin_data, env_vars)
+      stdin_data ||= ''
+      env_vars   ||= {}
+      in_proving_grounds do
+        with_bin_in_path do
+          Invocation.new *Open3.capture3(env_vars, command_string, stdin_data: stdin_data)
+        end
+      end
+    end
+
+    def execute_pipeline(command_strings, stdin_data, env_vars)
+      stdin_data ||= ''
+      env_vars   ||= {}
+      in_proving_grounds do
+        with_bin_in_path do
+          ioin, ioout, pids = Open3.pipeline_rw *command_strings.map { |cmd| [env_vars, cmd] }
+          ioin.print stdin_data
+          ioin.close
+          stderr = "" # uh... how do I record it for real?
+          Invocation.new ioout.read, stderr, pids.last.value
+        end
+      end
+    end
+
+    def with_bin_in_path
+      original_path = ENV['PATH']
+      dirs          = ENV["PATH"].split(File::PATH_SEPARATOR)
+      ENV['PATH']   = [config.bin_dir, *dirs].join(File::PATH_SEPARATOR)
+      yield
+    ensure
+      ENV['PATH'] = original_path
+    end
+  end
+end
 
 module SiBHelpers
   def method_result(name)
@@ -18,8 +61,9 @@ end
 World SiBHelpers
 
 Haiti.configure do |config|
-  config.proving_grounds_dir = File.expand_path '../../../proving_grounds', __FILE__
-  config.bin_dir             = File.expand_path '../../../bin',             __FILE__
+  lib_root                   = File.join __dir__, '..', '..'
+  config.proving_grounds_dir = File.expand_path 'proving_grounds', lib_root
+  config.bin_dir             = File.expand_path 'bin',             lib_root
 end
 
 
@@ -41,3 +85,18 @@ end
 Given %q(the file '$filename' '$body') do |filename, body|
   Haiti::CommandLineHelpers.write_file filename, eval_curlies(body)
 end
+
+Given /^I run the pipeline "([^"]*)"(?: *\| *"([^"]*)")*$/ do |*commands|
+  @last_executed = Haiti::CommandLineHelpers.execute_pipeline(
+    commands,
+    @stdin_data,
+    @env_vars_to_set
+  )
+end
+
+Given(/^the binary file "([^"]*)" "([^"]*)"$/) do |filename, body|
+  Haiti::CommandLineHelpers.in_proving_grounds do
+    FileUtils.mkdir_p File.dirname filename
+    File.open(filename, 'wb') { |file| file.write body }
+  end
+end

data/features/xmpfilter-style.feature

@@ -90,13 +90,14 @@ Feature: Xmpfilter style
     #    "0123456789\n"
     """
 
+
   Scenario: --xmpfilter-style overrides previous multiline results
     Given the file "xmpfilter-prev-line2.rb":
     """
     {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
     # =>
     """
-    When I run "seeing_is_believing --xmpfilter-style xmpfilter-prev-line2.rb | seeing_is_believing --xmpfilter-style"
+    When I run the pipeline "seeing_is_believing --xmpfilter-style xmpfilter-prev-line2.rb" | "seeing_is_believing --xmpfilter-style"
     Then stdout is:
     """
     {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
@@ -272,7 +273,7 @@ Feature: Xmpfilter style
       #     :wibble=>{:magic_word=>"xyzzy"}}
     end
     """
-    When I run "seeing_is_believing -x mutltiline_output_repeatedly_invoked.rb | seeing_is_believing -x"
+    When I run the pipeline "seeing_is_believing -x mutltiline_output_repeatedly_invoked.rb" | "seeing_is_believing -x"
     Then stdout is:
     """
     3.times do

data/lib/seeing_is_believing/binary/annotate_end_of_file.rb

@@ -37,15 +37,17 @@ class SeeingIsBelieving
       def exception_output_for(results, options)
         return '' unless results.has_exception?
         exception_marker = options[:markers][:exception][:prefix]
-        exception = results.exception
-        output = "\n"
-        output << FormatComment.new(0, exception_marker, exception.class_name, options).call << "\n"
-        exception.message.each_line do |line|
-          output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
-        end
-        output << exception_marker.sub(/\s+$/, '') << "\n"
-        exception.backtrace.each do |line|
-          output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
+        output = ""
+        results.exceptions.each do |exception|
+          output << "\n"
+          output << FormatComment.new(0, exception_marker, exception.class_name, options).call << "\n"
+          exception.message.each_line do |line|
+            output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
+          end
+          output << exception_marker.sub(/\s+$/, '') << "\n"
+          exception.backtrace.each do |line|
+            output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
+          end
         end
         output
       end

data/lib/seeing_is_believing/binary/annotate_every_line.rb

@@ -18,23 +18,24 @@ class SeeingIsBelieving
         @new_body ||= begin
           require 'seeing_is_believing/binary/comment_lines'
           require 'seeing_is_believing/binary/format_comment'
-          exception_text = @options[:markers][:exception][:prefix]
-          value_text     = @options[:markers][:value][:prefix]
+          exception_prefix = @options[:markers][:exception][:prefix]
+          value_prefix     = @options[:markers][:value][:prefix]
+          exceptions       = Hash.[] @results.exceptions.map { |e| [e.line_number, e] }
 
           alignment_strategy = @options[:alignment_strategy].new(@body)
-          exception_lineno   = @results.has_exception? ? @results.exception.line_number : -1
           new_body = CommentLines.call @body do |line, line_number|
-            options = @options.merge pad_to: alignment_strategy.line_length_for(line_number)
-            if exception_lineno == line_number
-              result = sprintf "%s: %s", @results.exception.class_name, @results.exception.message.gsub("\n", '\n')
-              FormatComment.call(line.size, exception_text, result, options)
+            exception = exceptions[line_number]
+            options   = @options.merge pad_to: alignment_strategy.line_length_for(line_number)
+            if exception
+              result = sprintf "%s: %s", exception.class_name, exception.message.gsub("\n", '\n')
+              FormatComment.call(line.size, exception_prefix, result, options)
             elsif @results[line_number].any?
               if @options[:interline_align]
                 result = @interline_align.call line_number, @results[line_number].map { |result| result.gsub "\n", '\n' }
               else
                 result = @results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
               end
-              FormatComment.call(line.size, value_text, result, options)
+              FormatComment.call(line.size, value_prefix, result, options)
             else
               ''
             end

data/lib/seeing_is_believing/binary/annotate_marked_lines.rb

@@ -94,23 +94,24 @@ class SeeingIsBelieving
         @new_body ||= begin
           require 'seeing_is_believing/binary/rewrite_comments'
           require 'seeing_is_believing/binary/format_comment'
-          include_lines = []
+          include_lines     = []
+          exception_results = {}
 
-          if @results.has_exception?
-            exception_result  = sprintf "%s: %s", @results.exception.class_name, @results.exception.message.gsub("\n", '\n')
-            exception_lineno  = @results.exception.line_number
-            include_lines << exception_lineno
+          @results.exceptions.each do |exception|
+            exception_results[exception.line_number] =
+              sprintf "%s: %s", exception.class_name, exception.message.gsub("\n", '\n')
+            include_lines << exception.line_number
           end
 
           _, pp_map = self.class.map_markers_to_linenos(@body, @options[:markers])
           new_body = RewriteComments.call @body, include_lines: include_lines do |comment|
-            exception_on_line  = exception_lineno == comment.line_number
+            exception_result   = exception_results[comment.line_number]
             annotate_this_line = comment.text[value_regex]
             pp_annotation      = annotate_this_line && comment.whitespace_col.zero?
             normal_annotation  = annotate_this_line && !pp_annotation
-            if exception_on_line && annotate_this_line
+            if exception_result && annotate_this_line
               [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, exception_result, @options)]
-            elsif exception_on_line
+            elsif exception_result
               whitespace = comment.whitespace
               whitespace = " " if whitespace.empty?
               [whitespace, FormatComment.call(0, exception_prefix, exception_result, @options)]

data/lib/seeing_is_believing/binary/config.rb

@@ -79,6 +79,11 @@ class SeeingIsBelieving
           self.deprecations << DeprecatedArgMessage.new(explanation: explanation, args: args)
         end
 
+        encodings_are_deprecated = lambda do |*args|
+          saw_deprecated.call "The ability to set encodings is deprecated. If you need this, details are at https://github.com/JoshCheek/seeing_is_believing/wiki/Encodings",
+                              *args
+        end
+
         next_arg = lambda do |flagname, argtype, &on_success|
           arg = args.shift
           arg ? on_success.call(arg) :
@@ -204,17 +209,26 @@ class SeeingIsBelieving
 
           when /\A-K(.+)/
             self.lib_options.encoding = $1
+            encodings_are_deprecated.call arg
 
           when '-K', '--encoding'
             next_arg.call arg, "an encoding" do |encoding|
               self.lib_options.encoding = encoding
+              encodings_are_deprecated.call arg, encoding
             end
 
           when /^(-.|--.*)$/
             unknown_flags << arg
 
           when /^-[^-]/
-            args.unshift *arg.scan(/[^-]\+?/).map { |flag| "-#{flag}" }
+            needs_arg = 'adDeIKnrst'
+            arg.scan(/[#{needs_arg}].*|h\+|[^-]\+?/).reverse.each do |flag|
+              if flag =~ /([#{needs_arg}])(.+)/
+                args.unshift "-#{$1}", $2
+              else
+                args.unshift "-#{flag}"
+              end
+            end
 
           else
             filenames << arg
@@ -249,6 +263,8 @@ class SeeingIsBelieving
           lib_options.event_handler = EventStream::Handlers::StreamJsonEvents.new(stdout)
         end
 
+        stdin.set_encoding 'utf-8'
+
         case debug
         when String
           debug_file    = File.open(debug, 'a').tap { |f| f.sync = true }
@@ -262,7 +278,8 @@ class SeeingIsBelieving
           add_error("Cannot give a program body and a filename to get the program body from.")
         elsif filename && file_class.exist?(filename)
           self.lib_options.stdin = stdin
-          self.body = file_class.read filename
+          # TODO: this doesn't seem like a safe assumption
+          self.body = file_class.read filename, external_encoding: "utf-8"
         elsif filename
           add_error("#{filename} does not exist!")
         elsif body
@@ -316,7 +333,6 @@ Options:
   -I,  --load-path dir           # a dir that should be added to the $LOAD_PATH
   -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
-  -K,  --encoding encoding       # sets file encoding, equivalent to Ruby's -Kx (see `man ruby` for valid values)
   -a,  --as filename             # run the program as if it was the specified filename
   -c,  --clean                   # remove annotations from previous runs of seeing_is_believing
   -g,  --debug                   # print debugging information

data/lib/seeing_is_believing/binary/engine.rb

@@ -36,16 +36,11 @@ class SeeingIsBelieving
       end
 
       def evaluate!
-        @evaluated || begin
-          SeeingIsBelieving.call normalized_cleaned_body,
-                                 config.lib_options.merge(event_handler: record_exit_events)
-          @timed_out = false
-          @evaluated = true
-        end
-      rescue Timeout::Error
-        @timed_out = true
-        @evaluated = true
-      ensure return self unless $! # idk, maybe too tricky, but was really annoying putting it in three places
+        @evaluated ||= !!SeeingIsBelieving.call(
+          normalized_cleaned_body,
+          config.lib_options.merge(event_handler: record_exit_events)
+        )
+        self
       end
 
       def timed_out?

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -12,12 +12,14 @@
 # its body will be incorrect, anyway.
 
 require 'rbconfig'
-require 'timeout'
+require 'socket'
 require 'seeing_is_believing/error'
 require 'seeing_is_believing/result'
 require 'seeing_is_believing/debugger'
 require 'seeing_is_believing/hard_core_ensure'
 require 'seeing_is_believing/event_stream/consumer'
+require "childprocess"
+ChildProcess.posix_spawn = true # forking locks up for some reason when we run SiB inside of SiB
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
@@ -31,7 +33,7 @@ class SeeingIsBelieving
       options = options.dup
       self.program           = program
       self.filename          = filename
-      self.encoding          = options.delete(:encoding)
+      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")
@@ -83,49 +85,47 @@ class SeeingIsBelieving
     end
 
     def write_program_to_file
-      File.open(filename, 'w') { |f| f.write program.to_s }
+      File.open(filename, 'w', external_encoding: "utf-8") { |f| f.write program.to_s }
     end
 
-    # have to basically copy a bunch of Open3 code into here b/c keywords don't work right when the keys are not symbols
-    # https://github.com/ruby/ruby/pull/808    my PR
-    # https://bugs.ruby-lang.org/issues/10699  they opened an issue
-    # https://bugs.ruby-lang.org/issues/10118  weird feature vs bug conversation
+
     def evaluate_file
+      event_server = TCPServer.new(0) # dynamically allocates an available port
+
       # setup streams
-      eventstream, child_eventstream = IO.pipe
-      stdout,      child_stdout      = IO.pipe
-      stderr,      child_stderr      = IO.pipe
-      child_stdin, stdin             = IO.pipe
+      stdout, child_stdout = IO.pipe("utf-8")
+      stderr, child_stderr = IO.pipe("utf-8")
 
       # setup environment variables
       env = ENV.to_hash.merge 'SIB_VARIABLES.MARSHAL.B64' =>
                                 [Marshal.dump(
-                                  event_stream_fd:   4,
+                                  event_stream_port: event_server.addr[1],
                                   max_line_captures: max_line_captures,
                                   num_lines:         program.lines.count,
                                   filename:          filename
                                 )].pack('m0')
 
-      # evaluate the code in a child process
-      opts = {
-        4 =>    child_eventstream,
-        in:     child_stdin,
-        out:    child_stdout,
-        err:    child_stderr,
-        pgroup: true, # run it in its own process group so we can SIGINT the whole group
-      }
-      child_pid  = Kernel.spawn(env, *popen_args, opts)
-      child_pgid = Process.getpgid(child_pid)
-
-      # close child streams b/c they won't emit EOF
-      # until both child and parent references are closed
-      close_streams(child_eventstream, child_stdout, child_stderr, child_stdin)
-      stdin.sync = true
+      child = ChildProcess.build(*popen_args)
+      child.leader = true
+      child.duplex = true
+      child.environment.merge!(env)
+      child.io.stdout = child_stdout
+      child.io.stderr = child_stderr
+
+      child.start
+
+      # close child streams b/c they won't emit EOF if parent still has an open reference
+      close_streams(child_stdout, child_stderr)
+      child.io.stdin.binmode
+      child.io.stdin.sync = true
+
+      # Start receiving events from the child
+      eventstream = event_server.accept
 
       # send stdin (char at a time b/c input could come from a stream)
       Thread.new do
-        provided_input.each_char { |char| stdin.write char }
-        stdin.close
+        provided_input.each_char { |char| child.io.stdin.write char }
+        child.io.stdin.close
       end
 
       # set up the event consumer
@@ -133,37 +133,52 @@ class SeeingIsBelieving
       consumer_thread = Thread.new { consumer.each { |e| event_handler.call e } }
 
       # wait for completion
-      Timeout.timeout timeout_seconds do
-        Process.wait child_pid
-        consumer.process_exitstatus($?.exitstatus)
-        consumer_thread.join
+      if timeout_seconds == 0
+        child.wait
+      else
+        child.poll_for_exit(timeout_seconds)
       end
-    rescue Timeout::Error
-      consumer.process_timeout timeout_seconds
-    ensure
-      allow_error(Errno::ESRCH)  { Process.kill "-INT", child_pgid } # negative makes it apply to the group
-      allow_error(Errno::ECHILD) { Process.wait child_pid } # I can't tell if this actually works, or just creates enough of a delay for the OS to finish cleaning up the thread
+      consumer.process_exitstatus(child.exit_code)
       consumer_thread.join
-      close_streams(stdin, stdout, stderr, eventstream)
+    rescue ChildProcess::TimeoutError
+      consumer.process_timeout(timeout_seconds)
+      child.stop
+      consumer_thread.join
+    ensure
+      # 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)
+      end
+      cleanup_run(child)
+      close_streams(stdout, stderr, eventstream, event_server)
     end
 
     def popen_args
       [RbConfig.ruby,
          '-W0',                                     # no warnings (b/c I hijack STDOUT/STDERR)
          *(encoding ? ["-K#{encoding}"] : []),      # allow the encoding to be set
-         '-I', File.expand_path('../..', __FILE__), # add lib to the load path
+         '-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]
     end
 
-    def allow_error(error)
-      yield
-    rescue error
-    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

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -7,6 +7,10 @@ require 'thread'
 class SeeingIsBelieving
   module EventStream
     class Consumer
+      # Contemplated doing FinishCriteria in binary, but the cost of doing it with an array
+      # like this is negligible and it has the nice advantage that the elements in the array
+      # are named # so if I ever look at it, I don't have to tranlsate a number to figure out
+      # the names https://gist.github.com/JoshCheek/10deb07277b6c85efc7b5e65c007785d
       class FinishCriteria
         EventThreadFinished  = Module.new
         StdoutThreadFinished = Module.new
@@ -57,7 +61,7 @@ class SeeingIsBelieving
           str = str.force_encoding(Encoding::UTF_8)
         end
         return str.scrub('�') if str.respond_to? :scrub
-        # basically reimplement scrub, b/c it's not implemented on 1.9.3
+        # basically reimplement scrub, b/c it's not implemented on 2.0.0
         str.each_char.inject("") do |new_str, char|
           if char.valid_encoding?
             new_str << char
@@ -124,6 +128,7 @@ class SeeingIsBelieving
       # from within the same thread as the consumer, because if it
       # blocks, who will remove items from the queue?
       def process_exitstatus(status)
+        status ||= 1 # see #100
         queue << lambda {
           queue << Events::Exitstatus.new(value: status)
           finish_criteria.received_exitstatus!