seeing_is_believing 3.3.0 → 4.0.1

data/lib/seeing_is_believing/wrap_expressions_with_inspect.rb

@@ -5,11 +5,14 @@ class SeeingIsBelieving
       # NOTE: if it received the AST, it could figure out if it needs
       # to always wrap the expression in parentheses
       WrapExpressions.call program,
+        before_all: -> {
+          "BEGIN { $SiB.file_loaded };"
+        },
         before_each: -> line_number {
           "$SiB.record_result(:inspect, #{line_number}, ("
         },
         after_each:  -> line_number {
-          "))"
+          ")) { |v| v.inspect }"
         }
     end
   end

data/seeing_is_believing.gemspec

@@ -12,20 +12,18 @@ Gem::Specification.new do |s|
   s.description = %q{Records the results of every line of code in your file (intended to be like xmpfilter), inspired by Bret Victor's JavaScript example in his talk "Inventing on Principle"}
   s.license     = "WTFPL"
 
-  s.rubyforge_project = "seeing_is_believing"
-
   s.files         = `git ls-files`.split("\n") - ['docs/seeing is believing.psd'] # remove psd b/c it boosts the gem size from 50kb to 20mb O.o
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency             "parser",      "~> 2.4.0"
-  s.add_dependency             "childprocess","~> 0.7.1"
+  s.add_dependency             "parser",      "~> 2.7.0"
+  s.add_dependency             "childprocess","~> 3.0.0"
+  s.add_dependency             "ffi",         "~> 1.11.1"
 
   s.add_development_dependency "pry"
   s.add_development_dependency "haiti",       ">= 0.1", "< 0.3"
-  s.add_development_dependency "rake",        "~> 12.0.0"
-  s.add_development_dependency "mrspec",      "~>  0.3.1"
+  s.add_development_dependency "rake",        "~> 13.0.0"
   s.add_development_dependency "rspec",       "~>  3.6.0"
   s.add_development_dependency "cucumber",    "~>  2.4"
   s.add_development_dependency "ripper-tags", "~>  0.3"

data/spec/binary/config_spec.rb

@@ -208,6 +208,16 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
     end
 
 
+    describe 'lib_options.local_cwd?' do
+      it 'defaults to false' do
+        expect(parse([]).lib_options.local_cwd?).to eq false
+      end
+      it 'is set to true by --local-cwd' do
+        expect(parse(['--local-cwd']).lib_options.local_cwd?).to eq true
+      end
+    end
+
+
     describe 'annotator_options.max_result_length' do
       it 'defaults to infinity' do
         expect(parse([]).annotator_options.max_result_length).to eq Float::INFINITY
@@ -247,8 +257,8 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse([]).lib_options.require_files).to eq [matrix_file]
       end
 
-      it 'appends pp and our customizations for xmpfilter style' do
-        expect(parse(['-x']).lib_options.require_files).to eq [matrix_file, 'pp', 'seeing_is_believing/customize_pp']
+      it 'appends pp for xmpfilter style' do
+        expect(parse(['-x']).lib_options.require_files).to eq [matrix_file, 'pp']
       end
 
       specify '-r and --require set an error if not provided with a filename' do
@@ -601,40 +611,58 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       it('defaults :stdout    to "# >> "') { expect(default_markers.stdout   .prefix).to eq "# >> " }
       it('defaults :stderr    to "# !> "') { expect(default_markers.stderr   .prefix).to eq "# !> " }
     end
-  end
 
-  describe 'print_event_stream?' do
-    it 'print_event_stream? is false by default' do
-      expect(parse([]).print_event_stream?).to eq false
-    end
-    it 'print_event_stream? can be turned on with --stream' do
-      expect(parse(['--stream']).print_event_stream?).to eq true
-    end
-    it 'adds an error if --stream is used with --json' do
-      expect(parse(['--stream'])).to_not have_error '--stream'
-      expect(parse(['--stream', '--json'])).to have_error '--stream'
-      expect(parse(['--json', '--stream'])).to have_error '--stream'
-    end
-    it 'adds an error if --stream is used with -x or --xmpfilter-style' do
-      expect(parse(['--stream'])).to_not have_error '--stream'
-      expect(parse(['--stream', '-x'])).to have_error '--stream'
-      expect(parse(['-x', '--stream'])).to have_error '--stream'
-      expect(parse(['--xmpfilter-style', '--stream'])).to have_error '--stream'
+    describe 'print_event_stream?' do
+      it 'print_event_stream? is false by default' do
+        expect(parse([]).print_event_stream?).to eq false
+      end
+      it 'print_event_stream? can be turned on with --stream' do
+        expect(parse(['--stream']).print_event_stream?).to eq true
+      end
+      it 'adds an error if --stream is used with --json' do
+        expect(parse(['--stream'])).to_not have_error '--stream'
+        expect(parse(['--stream', '--json'])).to have_error '--stream'
+        expect(parse(['--json', '--stream'])).to have_error '--stream'
+      end
+      it 'adds an error if --stream is used with -x or --xmpfilter-style' do
+        expect(parse(['--stream'])).to_not have_error '--stream'
+        expect(parse(['--stream', '-x'])).to have_error '--stream'
+        expect(parse(['-x', '--stream'])).to have_error '--stream'
+        expect(parse(['--xmpfilter-style', '--stream'])).to have_error '--stream'
+      end
     end
-  end
-
 
-  describe 'align_results?' do
-    it 'defaults to true' do
-      expect(parse([]).annotator_options.interline_align?).to eq true
-    end
-    it 'can be turned on with --interline-align' do
-      expect(parse(['--interline-align'])).to_not have_error '--interline-align'
-      expect(parse(['--interline-align']).annotator_options.interline_align?).to eq true
+    describe 'align_results?' do
+      it 'defaults to true' do
+        expect(parse([]).annotator_options.interline_align?).to eq true
+      end
+      it 'can be turned on with --interline-align' do
+        expect(parse(['--interline-align'])).to_not have_error '--interline-align'
+        expect(parse(['--interline-align']).annotator_options.interline_align?).to eq true
+      end
+      it 'can be turned off with --no-interline-align' do
+        expect(parse(['--no-interline-align'])).to_not have_error '--no-interline-align'
+        expect(parse(['--no-interline-align']).annotator_options.interline_align?).to eq false
+      end
     end
-    it 'can be turned off with --no-interline-align' do
-      expect(parse(['--no-interline-align'])).to_not have_error '--no-interline-align'
-      expect(parse(['--no-interline-align']).annotator_options.interline_align?).to eq false
+
+    describe 'toggle_mark/toggle_mark?' do
+      it 'defaults to nil/false' do
+        expect(parse([]).toggle_mark).to eq nil
+        expect(parse([]).toggle_mark?).to eq false
+      end
+      it 'can be set to true/linenum with --toggle-mark' do
+        expect(parse(['--toggle-mark', '123']).toggle_mark).to eq 123
+        expect(parse(['--toggle-mark', '123']).toggle_mark?).to eq true
+      end
+      it_behaves_like 'it requires a positive int argument', ['--toggle-mark']
+      it 'adds an error if used with --json or --stream' do
+        # expect(parse(['--toggle-mark', '123'])).to_not have_error /--toggle-mark/
+        expect(parse(['--stream', '--toggle-mark', '123'])).to have_error /--toggle-mark/
+        expect(parse(['--toggle-mark', '123', '--stream'])).to have_error /--toggle-mark/
+        expect(parse(['--json', '--toggle-mark', '123'])).to have_error /--toggle-mark/
+        expect(parse(['--toggle-mark', '123', '--json'])).to have_error /--toggle-mark/
+      end
     end
   end
 
@@ -677,11 +705,11 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
     end
 
     describe 'setting the body' do
-      it 'does not override the if already set e.g. with -e' do
+      it 'does not override the body if already set e.g. with -e' do
         expect(call(body: 'b', filename: nil).body).to eq 'b'
       end
 
-      it 'is the file body if the filename is provded and exists' do
+      it 'is the file body if the filename is provided and exists' do
         expect(call(body: nil, filename: existing_filename).body)
           .to eq file_body
       end
@@ -776,7 +804,7 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
 
       context 'when debug? is a string' do
-        let(:proving_grounds_dir) { File.realdirpath '../../proving_grounds', __dir__  }
+        let(:proving_grounds_dir) { File.expand_path '../../proving_grounds', __dir__  }
         let(:path)                { File.join proving_grounds_dir, 'test.log' }
         before                    { Dir.mkdir proving_grounds_dir unless Dir.exist? proving_grounds_dir }
 

data/spec/binary/engine_spec.rb

@@ -7,7 +7,8 @@ class SeeingIsBelieving
       def call(body, options={})
         timeout  = options.fetch :timeout, 0
         filename = options.fetch :filename, "program.rb"
-        config   = Config.new body: body, timeout_seconds: timeout
+        toggle   = options.fetch :toggled_mark, nil
+        config   = Config.new body: body, timeout_seconds: timeout, toggle_mark: toggle
         config.lib_options.timeout_seconds = timeout
         config.lib_options.filename        = filename
         Engine.new config
@@ -50,6 +51,15 @@ class SeeingIsBelieving
         end
       end
 
+      context 'toggled_mark' do
+        it 'has the mark toggled and doesn\'t change the newline' do
+          expect(call("1",        toggled_mark: 1).toggled_mark).to eq "1  # => "
+          expect(call("1 # => ",  toggled_mark: 1).toggled_mark).to eq "1"
+          expect(call("1\n",      toggled_mark: 1).toggled_mark).to eq "1  # => \n"
+          expect(call("1 # =>\n", toggled_mark: 1).toggled_mark).to eq "1\n"
+        end
+      end
+
       context 'before evaluating it raises if asked for' do
         specify('result')          { assert_must_evaluate :result }
         specify('exitstatus')      { assert_must_evaluate :exitstatus }

data/spec/binary/format_comment_spec.rb

@@ -60,7 +60,10 @@ RSpec.describe SeeingIsBelieving::Binary::FormatComment do
 
   def assert_printed(c, printed)
     c = c.force_encoding 'utf-8'
-    expect(result_for 0, '', c).to eq printed
+    result = result_for 0, '', c
+    expect(result).to eq printed
+    expect(result.encoding).to eq Encoding::UTF_8
+    expect(result).to be_valid_encoding
   end
 
   it 'escapes any non-printable characters' do
@@ -192,6 +195,7 @@ RSpec.describe SeeingIsBelieving::Binary::FormatComment do
     assert_printed 124.chr , "|"
     assert_printed 125.chr , "}"
     assert_printed 126.chr , "~"
+    assert_printed 127.chr, "\u007F"
   end
 
   it 'can be given a list of characters to not escape' do

data/spec/evaluate_by_moving_files_spec.rb

@@ -7,7 +7,7 @@ require 'fileutils'
 require 'childprocess'
 
 RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
-  let(:filedir)  { File.realdirpath '../proving_grounds', __dir__ }
+  let(:filedir)  { File.expand_path '../proving_grounds', __dir__ }
   let(:filename) { File.join filedir, 'some_filename' }
 
   before { FileUtils.mkdir_p filedir }
@@ -23,32 +23,32 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
   def invoke(program, options={})
     result = SeeingIsBelieving::Result.new
     options[:event_handler] ||= SeeingIsBelieving::EventStream::Handlers::UpdateResult.new(result)
-    evaluator = described_class.new(program, filename, options)
-    FileUtils.rm_f evaluator.backup_filename
+    evaluator = described_class.new(filename, program, program, options)
+    FileUtils.rm_f evaluator.backup_path
     evaluator.call
     result
   end
 
-  it 'evaluates the code when the file DNE' do
+  it 'evaluates the code as the given file' do
+    expect(invoke('print __FILE__').stdout).to eq filename
+  end
+
+  it 'evaluates the code when the given file DNE' do
     FileUtils.rm_f filename
     expect(invoke('print 1').stdout).to eq '1'
   end
 
-  it 'evaluates the code when the file Exists' do
+  it 'evaluates the code when the given file Exists' do
     FileUtils.touch filename
     expect(invoke('print 1').stdout).to eq '1'
   end
 
   it 'raises an error when the temp file already exists' do
-    evaluator = described_class.new('', filename, null_options)
-    FileUtils.touch evaluator.backup_filename
+    evaluator = described_class.new(filename, '', '', null_options)
+    FileUtils.touch evaluator.backup_path
     expect { evaluator.call }.to raise_error SeeingIsBelieving::TempFileAlreadyExists
   end
 
-  it 'evaluates the code as the given file' do
-    expect(invoke('print __FILE__').stdout).to eq filename
-  end
-
   it 'does not change the original file' do
     File.open(filename, 'w') { |f| f.write "ORIGINAL" }
     invoke '1 + 1'
@@ -56,29 +56,29 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'uses HardCoreEnsure to move the file back' do
-    evaluator = described_class.new 'PROGRAM', filename, null_options
+    evaluator = described_class.new filename, 'PROGRAM', 'PROGRAM', null_options
     File.open(filename, 'w') { |f| f.write 'ORIGINAL' }
-    FileUtils.rm_rf evaluator.backup_filename
+    FileUtils.rm_rf evaluator.backup_path
     expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
-      expect(File.exist? evaluator.backup_filename).to eq false
+      expect(File.exist? evaluator.backup_path).to eq false
       expect(File.read filename).to eq 'ORIGINAL'
 
       # after code
       options[:code].call rescue nil
-      expect(File.read evaluator.backup_filename).to eq 'ORIGINAL'
+      expect(File.read evaluator.backup_path).to eq 'ORIGINAL'
       expect(File.read filename).to eq 'PROGRAM'
 
       # after ensure
       options[:ensure].call
       expect(File.read filename).to eq 'ORIGINAL'
-      expect(File.exist? evaluator.backup_filename).to eq false
+      expect(File.exist? evaluator.backup_path).to eq false
     end
     evaluator.call
   end
 
   it 'uses HardCoreEnsure to delete the file if it wrote it where one did not previously exist' do
-    evaluator = described_class.new 'PROGRAM', filename, null_options
+    evaluator = described_class.new filename, 'PROGRAM', 'PROGRAM', null_options
     FileUtils.rm_rf filename
     expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
@@ -120,6 +120,22 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     end
   end
 
+  it 'sets the program\'s working directory to the file\'s directory, when given local_cwd' do
+    Dir.chdir '/' do
+      root   = File.expand_path '/'
+      result = invoke 'print Dir.pwd'
+      expect(result.stdout).to eq root
+      dir, cwd, file_path = invoke(<<-RUBY, local_cwd: true).stdout.lines.map(&:chomp)
+        puts File.expand_path(__dir__)
+        puts Dir.pwd
+        puts __FILE__
+      RUBY
+      expect(dir).to_not eq root
+      expect(cwd).to eq dir
+      expect(file_path).to eq File.basename(filename)
+    end
+  end
+
   it 'does not blow up on exceptions raised in at_exit blocks' do
     expect { invoke 'at_exit { raise "zomg" }' }.to_not raise_error
   end
@@ -133,7 +149,7 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
 
   it 'must provide an event handler, which receives the process\'s events' do
     # raises error
-    expect { described_class.new("", filename, {}) }
+    expect { described_class.new(filename, "", "", {}) }
       .to raise_error ArgumentError, /event_handler/
 
     # sees all the events
@@ -148,6 +164,7 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     result = invoke <<-RUBY, timeout_seconds: 0.5
     child_pid = spawn 'ruby', '-e', 'sleep' # child makes a grandchild which sleeps
     puts Process.pid, child_pid             # print ids so we can check they got killed
+    $stdout.flush
     sleep                                   # child sleeps
     RUBY
     post   = Time.now

data/spec/event_stream_spec.rb

@@ -305,6 +305,13 @@ module SeeingIsBelieving::EventStream
           producer.record_result :type, 1, obj
           expect(count).to eq 1
         end
+
+        it 'can deal with results of inspect that have singleton methods' do
+          str = "a string"
+          def str.inspect() self end
+          producer.record_result :type, 1, str
+          expect(consumer.call.inspected).to eq str
+        end
       end
 
       context 'inspect performed by the block' do
@@ -430,6 +437,13 @@ module SeeingIsBelieving::EventStream
         end
       end
 
+      it 'works with objects whose boolean inquiries have been messed with (#131)' do
+        exception = begin; raise; rescue; $!; end
+        bad_bool  = Object.new
+        def bad_bool.!(*) raise; end
+        producer.record_exception bad_bool, exception # should not explode
+      end
+
       context 'recorded line number | line num is provided | it knows the file | exception comes from within file' do
         let(:exception) { begin; raise "zomg"; rescue; $!; end }
         let(:linenum)   { __LINE__ - 1 }
@@ -650,6 +664,7 @@ module SeeingIsBelieving::EventStream
           [Events::StderrClosed     , :stderr_closed],
           [Events::EventStreamClosed, :event_stream_closed],
           [Events::Finished         , :finished],
+          [Events::FileLoaded       , :file_loaded],
         ]
         pairs.each { |klass, name| expect(klass.event_name).to eq name }
 

data/spec/seeing_is_believing_spec.rb

@@ -31,7 +31,7 @@ RSpec.describe SeeingIsBelieving do
   end
 
   root_path            = File.realpath("..", __dir__)
-  proving_grounds_path = File.realdirpath('proving_grounds', root_path)
+  proving_grounds_path = File.expand_path('proving_grounds', root_path)
   before(:all) { Dir.mkdir proving_grounds_path unless Dir.exist? proving_grounds_path }
   around { |spec| Dir.chdir proving_grounds_path, &spec }
 
@@ -251,8 +251,8 @@ RSpec.describe SeeingIsBelieving do
     # Currently we dont' differentiate between inline and multiline if statements,
     # also, we can't wrap the whole statement since it's void value, which means we'd have to introduce
     # the idea of multiple wrappings for the same line, which I just don't care enough about to consider
-    expect(values_for("def meth \n return 1 if true  \n end \n meth")).to eq [[], ['1'], [], ['1']]   # records true instead of 1
-    expect(values_for("def meth \n return 1 if false \n end \n meth")).to eq [[], ['nil'], [], ['nil']] # records false instead of nil
+    expect(values_for("def meth \n return 1 if true  \n end \n meth")).to eq [[], ['1'], [':meth'], ['1']]   # records true instead of 1
+    expect(values_for("def meth \n return 1 if false \n end \n meth")).to eq [[], ['nil'], [':meth'], ['nil']] # records false instead of nil
   end
 
   it 'does not try to record the keyword next' do
@@ -332,10 +332,23 @@ RSpec.describe SeeingIsBelieving do
     expect(result.stdout).to eq filename
   end
 
-  specify 'cwd of the file is the cwd of the evaluating program' do
-    filename = File.join proving_grounds_path, 'mah_file.rb'
-    FileUtils.rm_f filename
-    expect(invoke('print File.realdirpath(Dir.pwd)', filename: filename).stdout).to eq Dir.pwd
+  describe 'cwd' do
+    let(:filename) { File.join proving_grounds_path, 'mah_file.rb' }
+    before { FileUtils.rm_f filename }
+
+    it 'defaults to the cwd of the the evaluating program' do
+      dir = Dir.chdir '/' do
+        invoke('print File.expand_path(Dir.pwd)', filename: filename).stdout
+      end
+      expect(dir).to eq File.expand_path('/')
+    end
+
+    it 'is the file\'s directory when local_cwd is set' do
+      dir = Dir.chdir '/' do
+        invoke('print File.expand_path(Dir.pwd)', filename: filename, local_cwd: true).stdout
+      end
+      expect(dir).to eq proving_grounds_path
+    end
   end
 
   it 'does not capture output from __END__ onward' do
@@ -518,6 +531,17 @@ RSpec.describe SeeingIsBelieving do
     expect(result.exception.message).to match /recursive/i
   end
 
+  it 'does not blow up when returning an object that recursively responds to everything' do
+    result = invoke('obj = BasicObject.new
+                     def obj.method_missing(*) self; end
+                     obj')
+    expect(result[3][0]).to start_with '#<BasicObject:'
+  end
+
+  it 'does not blow up when the first line looks like it might have a magic comment in it (#126)' do
+    expect(values_for "1+1 # and a comment with 'Accept-Encoding: gzip' in it").to eq [['2']]
+  end
+
   it 'makes the SeeingIsBelieving::VERSION available to the program' do
     expect(values_for "SeeingIsBelieving::VERSION").to eq [[SeeingIsBelieving::VERSION.inspect]]
   end
@@ -530,6 +554,21 @@ RSpec.describe SeeingIsBelieving do
     expect(values_for 'o = BasicObject.new; def o.inspect; "some obj"; end; o').to eq [['some obj']]
   end
 
+  it 'sees refined inspect (#128)' do
+    result = invoke <<-RUBY
+    module BinMeUp
+      refine Integer do
+        def inspect
+          "%08b" % self
+        end
+      end
+    end
+    using BinMeUp
+    5
+    RUBY
+    expect(result[9]).to eq ['00000101']
+  end
+
   it 'respects timeout, even when children do semi-ridiculous things, it cleans up children rather than orphaning them' do
     pre    = Time.now
     result = invoke <<-CHILD, timeout_seconds: 0.5
@@ -611,6 +650,18 @@ RSpec.describe SeeingIsBelieving do
     end
   end
 
+  # Okay, doesn't totally belong here, b/c there could be another implementation which doesn't overwrite files,
+  # but it requires coordination between the rewritten code and the evaluator, so isn't really an evaluator unit test,
+  # so putting this here.
+  context 'cleaning up files' do
+    it 'replaces the rewritten source with the original source as soon as it sees a result' do
+      program = "sleep 0.01 while File.read(__FILE__).include?('RECORD_RESULT'.downcase); File.read __FILE__\n"
+      result  = invoke program
+      expect(result[1]).to eq [program.inspect]
+      expect(File.exist? result.filename).to eq false
+    end
+  end
+
 
   context 'when given a debugger' do
     let(:stream)   { StringIO.new }
@@ -766,33 +817,33 @@ RSpec.describe SeeingIsBelieving do
                      end').stderr).to eq ''
     end
 
-    specify 'when String does not have ==, to_s, inspect, to_i' do
+    specify 'when String does not have ==, to_s, inspect, to_i, ===' do
       expect(invoke('class String
                        undef ==
                        undef to_s
                        undef to_str
                        undef inspect
                        undef to_i
-                     end').stderr).to eq ''
+                     end
+                     class << String
+                       undef ===
+                     end
+                    ').stderr).to eq ''
     end
 
-    specify 'when Fixnum does not have <, <<, next, ==, inspect, to_s' do
-      if defined? Fixnum
-        result = invoke('class Fixnum
-                           undef <
-                           undef <<
-                           undef ==
-                           def next
-                             "redefining instead of undefing b/c it comes from Integer"
-                           end
-                           undef to_s
-                           undef inspect
-                         end
-                         "a"')
-        expect(result.stderr).to eq ''
-        expect(result.exitstatus).to eq 0
-        expect(result.to_a.last).to eq ['"a"']
-      end
+    specify 'when Integer does not have <, <<, next, ==, inspect, to_s' do
+      result = invoke('class Integer
+                         undef <
+                         undef <<
+                         undef ==
+                         undef next
+                         undef to_s
+                         undef inspect
+                       end
+                       "a"')
+      expect(result.stderr).to eq ''
+      expect(result.exitstatus).to eq 0
+      expect(result.to_a.last).to eq ['"a"']
     end
 
     specify 'when Integer does not have <, <<, next, ==, inspect, to_s' do
@@ -968,5 +1019,76 @@ RSpec.describe SeeingIsBelieving do
                      end
                     ').stderr).to eq ''
     end
+
+    def executes_without_error!(code)
+      result = invoke(code)
+      expect(result.stderr).to eq ''
+      begin
+        expect(result).to_not have_exception, result.exception.pretty_inspect
+      rescue NoMethodError
+        require 'pp'
+        retry
+      end
+      result
+    end
+
+    specify 'when constants are reassigned' do
+      result = executes_without_error!('
+         # producer
+         Hash            = "fake Hash"
+         String          = "fake String"
+         class << String
+           undef ===
+         end
+         Exception       = "fake Exception"
+
+         kernel          = Kernel
+         Kernel          = "fake Kernel"
+         SystemExit      = "fake SystemExit"
+         NoMethodError   = "fake NoMethodError"
+         Marshal         = "fake Marshal"
+         TypeError       = "fake TypeError"
+
+         # only matter when forking
+         Thread          = "fake Thread"
+         IOError         = "fake IOError"
+         Errno::EPIPE    = "fake Errno::EPIPE" # we don\'t actually put it in a situation to hit this
+         Errno           = "fake Errno"
+
+         # the matrix
+         Exception = "Exception"
+         Symbol    = "Symbol"
+
+         # normal inspect
+         1 + 1
+
+         # force it down the sad path
+         obj = Object.new
+         def obj.inspect
+           "pass"
+         end
+         obj
+         puts __LINE__-1 # so we know where to assert
+
+         NotAString = Module.new
+         def obj.inspect
+           NotAString
+         end
+         obj
+
+         def obj.inspect
+           raise "whoops"
+         end
+         obj
+         puts __LINE__-1 # should be replaced with Kernel#inspect
+
+         kernel.exit 0
+      ')
+
+      pass_str, kernel_inspect = result.stdout.lines.map(&:to_i)
+      expect(result[pass_str]).to eq ['pass']
+      expect(result[kernel_inspect].size).to eq 1
+      expect(result[kernel_inspect][0]).to match /^#<Object/
+    end
   end
 end