seeing_is_believing 2.1.3 → 2.1.4

data/spec/binary/rewrite_comments_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'seeing_is_believing/binary/rewrite_comments'
 
 describe SeeingIsBelieving::Binary::RewriteComments do
@@ -11,7 +12,7 @@ describe SeeingIsBelieving::Binary::RewriteComments do
       seen << args
       args[-2..-1]
     end
-    seen.should == []
+    expect(seen).to eq []
   end
 
   it 'yields the line_number, line upto the whitespace, whitespace, and comment' do
@@ -26,12 +27,12 @@ describe SeeingIsBelieving::Binary::RewriteComments do
       seen << args
       args[-2..-1]
     end
-    seen.should == [
+    expect(seen).to eq [
       [1,  "",     "",      "# c1"],
       [2,  "123",  " ",     "#   c2 # x"],
       [4,  "",     " \t ",  "# c3"],
       [6,  " 1}",  "",      "#c4"],
-      [7,  "",    "",      "# c5"],
+      [7,  "",     "",      "# c5"],
     ]
   end
 
@@ -44,11 +45,11 @@ describe SeeingIsBelieving::Binary::RewriteComments do
                      " 1}#c4") do |line_number, *|
       ["NEW_WHITESPACE#{line_number}", "--COMMENT-#{line_number}--"]
     end
-    rewritten.should == "NEW_WHITESPACE1--COMMENT-1--\n"\
-                        "123NEW_WHITESPACE2--COMMENT-2--\n"\
-                        "n456\n"\
-                        "NEW_WHITESPACE4--COMMENT-4--\n"\
-                        "%Q{\n"\
-                        " 1}NEW_WHITESPACE6--COMMENT-6--"
+    expect(rewritten).to eq "NEW_WHITESPACE1--COMMENT-1--\n"\
+                            "123NEW_WHITESPACE2--COMMENT-2--\n"\
+                            "n456\n"\
+                            "NEW_WHITESPACE4--COMMENT-4--\n"\
+                            "%Q{\n"\
+                            " 1}NEW_WHITESPACE6--COMMENT-6--"
   end
 end

data/spec/debugger_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'seeing_is_believing/debugger'
 require 'stringio'
 
@@ -5,32 +6,32 @@ describe SeeingIsBelieving::Debugger do
   let(:stream) { StringIO.new }
 
   specify 'is enabled when given a stream' do
-    described_class.new(stream: nil).should_not be_enabled
-    described_class.new(stream: stream).should be_enabled
+    expect(described_class.new(stream: nil)).to_not be_enabled
+    expect(described_class.new(stream: stream)).to be_enabled
   end
 
   specify 'colour is disabled by default' do
-    described_class.new.should_not be_coloured
-    described_class.new(colour: false).should_not be_coloured
-    described_class.new(colour:  true).should be_coloured
+    expect(described_class.new).to_not be_coloured
+    expect(described_class.new(colour: false)).to_not be_coloured
+    expect(described_class.new(colour:  true)).to be_coloured
   end
 
   context 'when given a stream' do
     it 'prints the the context and the value of the block' do
       described_class.new(stream: stream).context('C') { 'V' }
-      stream.string.should == "C:\nV\n"
+      expect(stream.string).to eq "C:\nV\n"
     end
 
     it 'colours the context when colour is set to true' do
       described_class.new(stream: stream, colour: true).context('C') { 'V' }
-      stream.string.should == "#{described_class::CONTEXT_COLOUR}C:#{described_class::RESET_COLOUR}\nV\n"
+      expect(stream.string).to eq "#{described_class::CONTEXT_COLOUR}C:#{described_class::RESET_COLOUR}\nV\n"
     end
   end
 
   context 'when not given a stream' do
     it 'prints nothing' do
       described_class.new.context('C') { 'V' }
-      stream.string.should be_empty
+      expect(stream.string).to be_empty
     end
 
     it 'does not evaluate the blocks' do

data/spec/evaluate_by_moving_files_spec.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+require 'spec_helper'
 require 'seeing_is_believing/evaluate_by_moving_files'
 require 'fileutils'
 
@@ -17,12 +18,12 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
 
   it 'evaluates the code when the file DNE' do
     FileUtils.rm_f filename
-    invoke('print 1').stdout.should == '1'
+    expect(invoke('print 1').stdout).to eq '1'
   end
 
   it 'evaluates the code when the file Exists' do
     FileUtils.touch filename
-    invoke('print 1').stdout.should == '1'
+    expect(invoke('print 1').stdout).to eq '1'
   end
 
   it 'raises an error when the temp file already exists' do
@@ -32,33 +33,33 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'evaluates the code as the given file' do
-    invoke('print __FILE__').stdout.should == filename
+    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'
-    File.read(filename).should == "ORIGINAL"
+    expect(File.read filename).to eq "ORIGINAL"
   end
 
   it 'uses HardCoreEnsure to move the file back' do
     evaluator = described_class.new 'PROGRAM', filename
     File.open(filename, 'w') { |f| f.write 'ORIGINAL' }
     FileUtils.rm_rf evaluator.temp_filename
-    SeeingIsBelieving::HardCoreEnsure.should_receive(:call) do |options|
+    expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
-      File.exist?(evaluator.temp_filename).should == false
-      File.read(filename).should == 'ORIGINAL'
+      expect(File.exist? evaluator.temp_filename).to eq false
+      expect(File.read filename).to eq 'ORIGINAL'
 
       # after code
       options[:code].call rescue nil
-      File.read(evaluator.temp_filename).should == 'ORIGINAL'
-      File.read(filename).should == 'PROGRAM'
+      expect(File.read evaluator.temp_filename).to eq 'ORIGINAL'
+      expect(File.read filename).to eq 'PROGRAM'
 
       # after ensure
       options[:ensure].call
-      File.read(filename).should == 'ORIGINAL'
-      File.exist?(evaluator.temp_filename).should == false
+      expect(File.read filename).to eq 'ORIGINAL'
+      expect(File.exist? evaluator.temp_filename).to eq false
     end
     evaluator.call
   end
@@ -66,17 +67,17 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
   it 'uses HardCoreEnsure to delete the file if it wrote it where one did not previously exist' do
     evaluator = described_class.new 'PROGRAM', filename
     FileUtils.rm_rf filename
-    SeeingIsBelieving::HardCoreEnsure.should_receive(:call) do |options|
+    expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
-      File.exist?(filename).should == false
+      expect(File.exist? filename).to eq false
 
       # after code
       options[:code].call rescue nil
-      File.read(filename).should == 'PROGRAM'
+      expect(File.read filename).to eq 'PROGRAM'
 
       # after ensure
       options[:ensure].call
-      File.exist?(filename).should == false
+      expect(File.exist? filename).to eq false
     end
     evaluator.call
   end
@@ -87,17 +88,23 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
     File.open(other_filename1, 'w') { |f| f.puts "puts 123" }
     File.open(other_filename2, 'w') { |f| f.puts "puts 456" }
     result = invoke '', require: [other_filename1, other_filename2]
-    result.stdout.should == "123\n456\n"
+    expect(result.stdout).to eq "123\n456\n"
   end
 
   it 'can set the load path' do
     File.open(File.join(filedir, 'other1.rb'), 'w') { |f| f.puts "puts 123" }
     result = invoke '', require: ['other1'], load_path: [filedir]
-    result.stdout.should == "123\n"
+    expect(result.stdout).to eq "123\n"
   end
 
   it 'will set the encoding' do
-    invoke('print "ç"', encoding: 'u').stdout.should == "ç"
+    test = -> { expect(invoke('print "ç"', encoding: 'u').stdout).to eq "ç" }
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      pending "Rubinius doesn't seem to use -Kx, but rather -U"
+      test.call
+    else
+      test.call
+    end
   end
 
   it 'if it fails, it prints some debugging information and raises an error' do
@@ -105,6 +112,6 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
     evaluator = described_class.new 'raise "omg"', filename, debugger: SeeingIsBelieving::Debugger.new(stream: error_stream)
     FileUtils.rm_f evaluator.temp_filename
     expect { evaluator.call }.to raise_error SeeingIsBelieving::BugInSib
-    error_stream.string.should include "Program could not be evaluated"
+    expect(error_stream.string).to include "Program could not be evaluated"
   end
 end

data/spec/hard_core_ensure_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'ichannel'
 require 'seeing_is_believing/hard_core_ensure'
 
@@ -23,13 +24,13 @@ describe SeeingIsBelieving::HardCoreEnsure do
   end
 
   it 'invokes the code and returns the value' do
-    call(code: -> { :result }, ensure: -> {}).should == :result
+    expect(call(code: -> { :result }, ensure: -> {})).to eq :result
   end
 
   it 'invokes the ensure after the code' do
     seen = []
     call code: -> { seen << :code }, ensure: -> { seen << :ensure }
-    seen.should == [:code, :ensure]
+    expect(seen).to eq [:code, :ensure]
   end
 
   it 'invokes the ensure even if an exception is raised' do
@@ -37,22 +38,30 @@ describe SeeingIsBelieving::HardCoreEnsure do
     expect do
       call code: -> { raise Exception, 'omg!' }, ensure: -> { ensure_invoked = true }
     end.to raise_error Exception, 'omg!'
-    ensure_invoked.should == true
+    expect(ensure_invoked).to eq true
   end
 
   it 'invokes the code even if an interrupt is sent and there is a default handler' do
-    channel = IChannel.new Marshal
-    pid = fork do
-      old_handler = trap('INT') { channel.put "old handler invoked" }
-      call code: -> { sleep 0.1 }, ensure: -> { channel.put "ensure invoked" }
-      trap 'INT', old_handler
+    test = lambda do
+      channel = IChannel.new Marshal
+      pid = fork do
+        old_handler = trap('INT') { channel.put "old handler invoked" }
+        call code: -> { sleep 0.1 }, ensure: -> { channel.put "ensure invoked" }
+        trap 'INT', old_handler
+      end
+      sleep 0.05
+      Process.kill 'INT', pid
+      Process.wait pid
+      expect(channel.get).to eq "ensure invoked"
+      expect(channel.get).to eq "old handler invoked"
+      expect(channel).to_not be_readable
+    end
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      pending "Skipping this test on jruby b/c the JVM doesn't have a fork"
+      raise
+    else
+      test.call
     end
-    sleep 0.05
-    Process.kill 'INT', pid
-    Process.wait pid
-    channel.get.should == "ensure invoked"
-    channel.get.should == "old handler invoked"
-    channel.should_not be_readable
   end
 
   it 'invokes the code even if an interrupt is sent and interrupts are set to ignore' do
@@ -67,15 +76,18 @@ describe SeeingIsBelieving::HardCoreEnsure do
       sleep 0.05
       Process.kill 'INT', pid
       Process.wait pid
-      channel.get.should == "ensure invoked"
-      channel.get.should == 'code result'
-      channel.should_not be_readable
+      expect(channel.get).to eq "ensure invoked"
+      expect(channel.get).to eq 'code result'
+      expect(channel).to_not be_readable
     end
 
-    if RUBY_VERSION == '2.1.1' || RUBY_VERSION == '2.1.2'
-      pending 'This test can\'t run on 2.1.1 or 2.1.2'
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      pending "Skipping this test on jruby b/c the JVM doesn't have a fork"
+    elsif (!defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby') && (RUBY_VERSION == '2.1.1' || RUBY_VERSION == '2.1.2')
+      pending 'This test can\'t run on MRI (2.1.1 or 2.1.2) b/c of bug, see https://github.com/JoshCheek/seeing_is_believing/issues/26'
+      raise # new rspec will keep executing code and fail b/c nothing is raised
     else
-      test.call
+      test.call # works on Rubinius
     end
   end
 end

data/spec/line_spec.rb

@@ -1,6 +1,7 @@
+require 'spec_helper'
 require 'seeing_is_believing/result'
 
-describe SeeingIsBelieving::Line, t:true do
+describe SeeingIsBelieving::Line do
   Line = described_class
 
   def line_for(*args)
@@ -10,18 +11,18 @@ describe SeeingIsBelieving::Line, t:true do
   end
 
   it 'inspects prettily' do
-    line_for(       ).inspect.should == '#<SIB:Line[] (0, 0) no exception>'
-    line_for("a"    ).inspect.should == '#<SIB:Line["\"a\""] (1, 3) no exception>'
-    line_for("a", 12).inspect.should == '#<SIB:Line["\"a\"", "12"] (2, 5) no exception>'
+    expect(line_for(       ).inspect).to eq '#<SIB:Line[] (0, 0) no exception>'
+    expect(line_for("a"    ).inspect).to eq '#<SIB:Line["\"a\""] (1, 3) no exception>'
+    expect(line_for("a", 12).inspect).to eq '#<SIB:Line["\"a\"", "12"] (2, 5) no exception>'
 
     line = Line.new
     line.exception = RuntimeError.new("omg")
-    line.inspect.should == '#<SIB:Line[] (0, 0) RuntimeError:"omg">'
+    expect(line.inspect).to eq '#<SIB:Line[] (0, 0) RuntimeError:"omg">'
   end
 
   it "doesn't blow up when there is no #inspect available e.g. BasicObject" do
     obj = BasicObject.new
-    line_for(obj).inspect.should == '#<SIB:Line["#<no inspect available>"] (1, 23) no exception>'
+    expect(line_for(obj).inspect).to eq '#<SIB:Line["#<no inspect available>"] (1, 23) no exception>'
   end
 
   it "doesn't blow up when #inspect returns a not-String (e.g. pathalogical libraries like FactoryGirl)" do
@@ -29,57 +30,57 @@ describe SeeingIsBelieving::Line, t:true do
     def obj.inspect
       nil
     end
-    line_for(obj).inspect.should == '#<SIB:Line["#<no inspect available>"] (1, 23) no exception>'
+    expect(line_for(obj).inspect).to eq '#<SIB:Line["#<no inspect available>"] (1, 23) no exception>'
   end
 
   it 'knows when it has an exception' do
     exception = RuntimeError.new 'omg'
     line = Line.new
-    line.should_not have_exception
+    expect(line).to_not have_exception
     line.exception = exception
-    line.should have_exception
-    line.exception.should equal exception
+    expect(line).to have_exception
+    expect(line.exception).to equal exception
   end
 
   it 'delegates its other methods to array, but returns itself where the array would be returned' do
     line = Line.new
-    line.should be_empty
-    (line << 1).should equal line
-    line.should_not be_empty
-    line.map { |i| i * 2 }.should == [2]
+    expect(line).to be_empty
+    expect((line << 1)).to equal line
+    expect(line).to_not be_empty
+    expect(line.map { |i| i * 2 }).to eq [2]
     line << 10 << 100
-    line.take(2).should == [1, 10]
+    expect(line.take(2)).to eq [1, 10]
   end
 
   it 'returns its array for #to_a and #to_ary' do
     line = line_for 1, 2
-    line.to_a.should be_a_kind_of Array
-    line.to_a.should == %w[1 2]
-    line.to_ary.should be_a_kind_of Array
-    line.to_ary.should == %w[1 2]
+    expect(line.to_a).to be_a_kind_of Array
+    expect(line.to_a).to eq %w[1 2]
+    expect(line.to_ary).to be_a_kind_of Array
+    expect(line.to_ary).to eq %w[1 2]
   end
 
   it 'is equal to arrays with the same elements as its array' do
-    line_for(1, 2).should == %w[1 2]
-    line_for(1, 2).should_not == %w[2 1]
+    expect(line_for(1, 2)).to eq %w[1 2]
+    expect(line_for(1, 2)).to_not eq %w[2 1]
   end
 
   # Exception equality seems to be based off of the message, and be indifferent to the class, I don't think it's that important to fix it
   it "is equal to lines with the same elements and the same exception" do
     exception = RuntimeError.new 'omg'
 
-    line_for(1, 2).should == line_for(1, 2)
-    line_for(1, 2).should_not == line_for(2, 1)
+    expect(line_for(1, 2)).to eq line_for(1, 2)
+    expect(line_for(1, 2)).to_not eq line_for(2, 1)
 
     line1 = line_for(1, 2)
     line1.exception = exception
-    line1.should_not == line_for(1, 2)
+    expect(line1).to_not eq line_for(1, 2)
 
     line2 = line_for(1, 2)
     line2.exception = exception
-    line1.should == line2
+    expect(line1).to eq line2
 
     line2.exception = RuntimeError.new 'wrong message'
-    line1.should_not == line2
+    expect(line1).to_not eq line2
   end
 end

data/spec/seeing_is_believing_spec.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+require 'spec_helper'
 require 'seeing_is_believing'
 require 'stringio'
 
@@ -13,55 +14,59 @@ describe SeeingIsBelieving do
 
   let(:proving_grounds_dir) { File.expand_path '../../proving_grounds', __FILE__ }
 
-  it 'takes a string or and returns a result of the line numbers (counting from 1) and each inspected result from that line' do
+  it 'takes a string and returns a result of the line numbers (counting from 1) and each inspected result from that line' do
     input  = "10+10\n'2'+'2'"
-    invoke(input)[1].should == ["20"]
-    invoke(input)[2].should == ['"22"']
+    expect(invoke(input)[1]).to eq ["20"]
+    expect(invoke(input)[2]).to eq ['"22"']
   end
 
   it 'only invokes inspect once' do
     input = "class Fixnum; def inspect; 'NUM'\nend\nend\n1"
-    invoke(input)[1].should == ['"NUM"']
+    expect(invoke(input)[1]).to eq ['"NUM"']
   end
 
   it 'remembers context of previous lines' do
-    values_for("a=12\na*2").should == [['12'], ['24']]
+    expect(values_for("a=12\na*2")).to eq [['12'], ['24']]
   end
 
   it 'can be invoked multiple times, returning the same result' do
     believer = described_class.new("$xyz||=1\n$xyz+=1")
-    believer.call.to_a.should == [['1'], ['2']]
-    believer.call.to_a.should == [['1'], ['2']]
+    expect(believer.call.to_a).to eq [['1'], ['2']]
+    expect(believer.call.to_a).to eq [['1'], ['2']]
   end
 
   it 'is evaluated at the toplevel' do
-    values_for('self').should == [['main']]
+    expect(values_for('self')).to eq [['main']]
   end
 
   it 'records the value immediately, so that it is correct even if the result is mutated' do
-    values_for("a = 'a'\na << 'b'").should == [['"a"'], ['"ab"']]
+    expect(values_for("a = 'a'\na << 'b'")).to eq [['"a"'], ['"ab"']]
   end
 
   it 'records each value when a line is evaluated multiple times' do
-    values_for("(1..2).each do |i|\ni\nend").should == [['1..2'], ['1', '2'], ['1..2']]
+    expect(values_for("(1..2).each do |i|\ni\nend")).to eq [['1..2'], ['1', '2'], ['1..2']]
   end
 
   # now that we're using Parser, there's very very few of these
   it 'evalutes to an empty array for lines that it cannot understand' do
-    values_for("[3].map \\\ndo |n|\n n*2\n end").should == [['[3]'], [], ['6'], ['[6]']]
-    values_for("'\n1\n'").should == [[], [], ['"\n1\n"']]
-    values_for("<<HEREDOC\n\n1\nHEREDOC").should ==  [[%Q'"\\n1\\n"']] # newlines escaped b/c lib inspects them
-    values_for("<<-HEREDOC\n\n1\nHEREDOC").should == [[%Q'"\\n1\\n"']]
+    expect(values_for("[3].map \\\ndo |n|\n n*2\n end")).to eq [['[3]'], [], ['6'], ['[6]']]
+    expect(values_for("'\n1\n'")).to eq [[], [], ['"\n1\n"']]
+    expect(values_for("<<HEREDOC\n\n1\nHEREDOC")).to eq  [[%Q'"\\n1\\n"']] # newlines escaped b/c lib inspects them
+    expect(values_for("<<-HEREDOC\n\n1\nHEREDOC")).to eq [[%Q'"\\n1\\n"']]
   end
 
   it 'records the targets of chained methods' do
-    values_for("[*1..5]\n.map { |n| n * 2 }\n.take(2)\n.size").should ==
+    expect(values_for("[*1..5]\n.map { |n| n * 2 }\n.take(2)\n.size")).to eq\
       [["[1, 2, 3, 4, 5]"], ["[2, 4, 6, 8, 10]"], ["[2, 4]"], ["2"]]
   end
 
+  it 'does not add additional vars' do
+    expect(values_for 'local_variables').to eq [["[]"]]
+  end
+
   it "records heredocs" do
-    values_for("<<A\n1\nA").should == [[%'"1\\n"']]
-    values_for("<<-A\n1\nA").should == [[%'"1\\n"']]
+    expect(values_for("<<A\n1\nA")).to eq [[%'"1\\n"']]
+    expect(values_for("<<-A\n1\nA")).to eq [[%'"1\\n"']]
   end
 
   it 'does not insert code into the middle of heredocs' do
@@ -82,69 +87,69 @@ describe SeeingIsBelieving do
       DOC5
     HEREDOC
 
-    invoked.stdout.should == "doc1\ndoc2\ndoc3\ndoc4\ndoc5\n"
+    expect(invoked.stdout).to eq "doc1\ndoc2\ndoc3\ndoc4\ndoc5\n"
   end
 
   it 'has no output for empty lines' do
-    values_for('').should == [[]]
-    values_for('  ').should == [[]]
-    values_for("  \n").should == [[]]
-    values_for("1\n\n2").should == [['1'],[],['2']]
+    expect(values_for('')).to eq [[]]
+    expect(values_for('  ')).to eq [[]]
+    expect(values_for("  \n")).to eq [[]]
+    expect(values_for("1\n\n2")).to eq [['1'],[],['2']]
   end
 
   it 'stops executing on errors and reports them' do
-    invoke("'no exception'").should_not have_exception
+    expect(invoke("'no exception'")).to_not have_exception
 
     result = invoke("12\nraise Exception, 'omg!'\n12")
-    result.should have_exception
-    result.exception.message.should == 'omg!'
+    expect(result).to have_exception
+    expect(result.exception.message).to eq 'omg!'
 
-    result[1].should == ['12']
+    expect(result[1]).to eq ['12']
 
-    result[2].should == []
-    result[2].exception.should == result.exception
+    expect(result[2]).to eq []
+    expect(result[2].exception).to eq result.exception
 
-    result[3].should == []
+    expect(result[3]).to eq []
   end
 
   it 'records the backtrace on the errors' do
     result = invoke("12\nraise Exception, 'omg!'\n12")
-    result.exception.backtrace.should be_a_kind_of Array
+    expect(result.exception.backtrace).to be_a_kind_of Array
   end
 
   it 'does not fuck up __LINE__ macro' do
-    values_for('__LINE__
-                __LINE__
+    expect(values_for( '__LINE__
+                        __LINE__
 
-                def meth
-                  __LINE__
-                end
-                meth
+                        def meth
+                          __LINE__
+                        end
+                        meth
 
-                # comment
-                __LINE__').should == [['1'], ['2'], [], [], ['5'], [], ['5'], [], [], ['10']]
+                        # comment
+                        __LINE__')
+    ).to eq [['1'], ['2'], [], [], ['5'], [], ['5'], [], [], ['10']]
   end
 
   it 'records return statements' do
-    values_for("def meth \n return 1          \n end \n meth").should == [[], ['1'], [], ['1']]
-    values_for("-> {  \n return 1          \n }.call"        ).should == [[], ['1'], ['1']]
-    values_for("-> { return 1 }.call"                        ).should == [['1']]
-
-    pending "would be really cool if this would record 1 and nil, but it probably won't ever happen." 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
-      values_for("def meth \n return 1 if true  \n end \n meth").should == [[], ['1'], [], ['1']]   # records true instead of 1
-      values_for("def meth \n return 1 if false \n end \n meth").should == [[], ['nil'], [], ['nil']] # records false instead of nil
-    end
+    expect(values_for("def meth \n return 1          \n end \n meth")).to eq [[], ['1'], [], ['1']]
+    expect(values_for("-> {  \n return 1          \n }.call"        )).to eq [[], ['1'], ['1']]
+    expect(values_for("-> { return 1 }.call"                        )).to eq [['1']]
+
+    pending "would be really cool if this would record 1 and nil, but it probably won't ever happen."
+    # 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
   end
 
   it 'does not try to record the keyword next' do
-    values_for("(1..2).each do |i|\nnext if i == 1\ni\nend").should == [['1..2'], ['true', 'false'], ['2'], ['1..2']]
+    expect(values_for("(1..2).each do |i|\nnext if i == 1\ni\nend")).to eq [['1..2'], ['true', 'false'], ['2'], ['1..2']]
   end
 
   it 'does not try to record the keyword redo' do
-    values_for(<<-DOC).should == [[], ['0'], ['0...3'], ['1', '2', '3', '4'], ['false', 'true', 'false', 'false'], ['0...3'], [], ['0...3']]
+    expect(values_for(<<-DOC)).to eq [[], ['0'], ['0...3'], ['1', '2', '3', '4'], ['false', 'true', 'false', 'false'], ['0...3'], [], ['0...3']]
       def meth
         n = 0
         for i in 0...3
@@ -157,7 +162,7 @@ describe SeeingIsBelieving do
   end
 
   it 'does not try to record the keyword retry' do
-    values_for(<<-DOC).should == [[], [], [], [], ['nil']]
+    expect(values_for(<<-DOC)).to eq [[], [], [], [], ['nil']]
       def meth
       rescue
         retry
@@ -167,13 +172,13 @@ describe SeeingIsBelieving do
   end
 
   it 'does not try to record the keyword retry' do
-    values_for(<<-DOC).should == [['0..2'], ['0'], [], ['nil']]
+    expect(values_for(<<-DOC)).to eq [['0..2'], ['0'], [], ['nil']]
       (0..2).each do |n|
         n
         break
       end
     DOC
-    values_for(<<-DOC).should == [['0..2'], ['0'], ['10'], ['10']]
+    expect(values_for(<<-DOC)).to eq [['0..2'], ['0'], ['10'], ['10']]
       (0..2).each do |n|
         n
         break 10
@@ -183,7 +188,7 @@ describe SeeingIsBelieving do
 
   it 'does not affect its environment' do
     invoke 'def Object.abc() end'
-    Object.should_not respond_to :abc
+    expect(Object).to_not respond_to :abc
   end
 
   it 'captures the standard output and error' do
@@ -194,36 +199,36 @@ describe SeeingIsBelieving do
                      $stderr.puts '3'
                      $stdout = $stderr
                      puts '4'"
-    result.stdout.should == "a\nb\n" "a\nb\n" "c\n" "d\n"
-    result.stderr.should == "1\n2\n" "3\n" "4\n"
-    result.should have_stdout
-    result.should have_stderr
+    expect(result.stdout).to eq "a\nb\n" "a\nb\n" "c\n" "d\n"
+    expect(result.stderr).to eq "1\n2\n" "3\n" "4\n"
+    expect(result).to have_stdout
+    expect(result).to have_stderr
 
     result = invoke '1+1'
-    result.should_not have_stdout
-    result.should_not have_stderr
+    expect(result).to_not have_stdout
+    expect(result).to_not have_stderr
   end
 
   it 'defaults the filename to temp_dir/program.rb' do
     result = invoke('print File.expand_path __FILE__')
-    File.basename(result.stdout).should == 'program.rb'
+    expect(File.basename(result.stdout)).to eq 'program.rb'
   end
 
   it 'can be told to run as a given file (in a given dir/with a given filename)' do
     filename = File.join proving_grounds_dir, 'mah_file.rb'
     FileUtils.rm_f filename
     result   = invoke 'print File.expand_path __FILE__', filename: filename
-    result.stdout.should == filename
+    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_dir, 'mah_file.rb'
     FileUtils.rm_f filename
-    invoke('print File.expand_path(Dir.pwd)', filename: filename).stdout.should == Dir.pwd
+    expect(invoke('print File.expand_path(Dir.pwd)', filename: filename).stdout).to eq Dir.pwd
   end
 
   it 'does not capture output from __END__ onward' do
-    values_for("1+1\nDATA.read\n__END__\n....").should == [['2'], ['"....\n"']] # <-- should this actually write a newline on the end?
+    expect(values_for("1+1\nDATA.read\n__END__\n....")).to eq [['2'], ['"....\n"']] # <-- should this actually write a newline on the end?
   end
 
   it 'raises a SyntaxError when the whole program is invalid' do
@@ -231,26 +236,26 @@ describe SeeingIsBelieving do
   end
 
   it 'can be given a stdin stream' do
-    invoke('$stdin.read', stdin: StringIO.new("input"))[1].should == ['"input"']
+    expect(invoke('$stdin.read', stdin: StringIO.new("input"))[1]).to eq ['"input"']
   end
 
   it 'can be given a stdin string' do
-    invoke('$stdin.read', stdin: "input")[1].should == ['"input"']
+    expect(invoke('$stdin.read', stdin: "input")[1]).to eq ['"input"']
   end
 
   it 'defaults the stdin stream to an empty string' do
-    invoke('$stdin.read')[1].should == ['""']
+    expect(invoke('$stdin.read')[1]).to eq ['""']
   end
 
   it 'can deal with methods that are invoked entirely on the next line' do
-    values_for("a = 1\n.even?\na").should == [['1'], ['false'], ['false']]
-    values_for("a = 1.\neven?\na").should == [['1'], ['false'], ['false']]
-    values_for("1\n.even?\n__END__").should == [['1'], ['false']]
+    expect(values_for("a = 1\n.even?\na")).to eq [['1'], ['false'], ['false']]
+    expect(values_for("a = 1.\neven?\na")).to eq [['1'], ['false'], ['false']]
+    expect(values_for("1\n.even?\n__END__")).to eq [['1'], ['false']]
   end
 
   it 'does not record leading comments' do
-    values_for("# -*- coding: utf-8 -*-\n'ç'\n__LINE__").should == [[], ['"ç"'], ['3']]
-    values_for("=begin\n1\n=end\n=begin\n=end\n__LINE__").should == [[], [], [],
+    expect(values_for("# -*- coding: utf-8 -*-\n'ç'\n__LINE__")).to eq [[], ['"ç"'], ['3']]
+    expect(values_for("=begin\n1\n=end\n=begin\n=end\n__LINE__")).to eq [[], [], [],
                                                                      [], [],
                                                                      ['6']]
   end
@@ -260,55 +265,55 @@ describe SeeingIsBelieving do
   end
 
   it 'records the exit status' do
-    invoke('raise "omg"').exitstatus.should == 1
-    invoke('exit 123').exitstatus.should == 123
-    invoke('at_exit { exit 121 }').exitstatus.should == 121
+    expect(invoke('raise "omg"').exitstatus).to eq 1
+    expect(invoke('exit 123').exitstatus).to eq 123
+    expect(invoke('at_exit { exit 121 }').exitstatus).to eq 121
   end
 
   it 'records lines that have comments on them' do
-    values_for('1+1 # comment uno
-                #comment dos
-                3#comment tres').should == [['2'], [], ['3']]
+    expect(values_for('1+1 # comment uno
+                      #comment dos
+                      3#comment tres')).to eq [['2'], [], ['3']]
   end
 
   it "doesn't fuck up when there are lines with magic comments in the middle of the app" do
-    values_for('1+1
-                # encoding: wtf').should == [['2']]
+    expect(values_for '1+1
+                       # encoding: wtf').to eq [['2']]
   end
 
   it "doesn't remove multiple leading comments" do
-    values_for("#!/usr/bin/env ruby\n"\
-               "# encoding: utf-8\n"\
-               "'ç'").should == [[], [], ['"ç"']]
-    values_for("#!/usr/bin/env ruby\n"\
-               "1 # encoding: utf-8\n"\
-               "2").should == [[], ['1'], ['2']]
+    expect(values_for "#!/usr/bin/env ruby\n"\
+                      "# encoding: utf-8\n"\
+                      "'ç'").to eq [[], [], ['"ç"']]
+    expect(values_for "#!/usr/bin/env ruby\n"\
+                      "1 # encoding: utf-8\n"\
+                      "2").to eq [[], ['1'], ['2']]
   end
 
   it 'can record the middle of a chain of calls'  do
-    values_for("1 +\n2").should == [['1'], ['3']]
-    values_for("1\\\n+ 2").should == [['1'], ['3']]
-    values_for("[*1..5]
-                  .select(&:even?)
-                  .map { |n| n * 3 }").should == [['[1, 2, 3, 4, 5]'],
-                                                  ['[2, 4]'],
-                                                  ['[6, 12]']]
-    values_for("[*1..5]
-                  .select(&:even?)
-                  .map { |n| n * 2 }.
-                  map  { |n| n / 2 }\\
-                  .map { |n| n * 3 }").should == [['[1, 2, 3, 4, 5]'],
-                                                  ['[2, 4]'],
-                                                  ['[4, 8]'],
-                                                  ['[2, 4]'],
-                                                  ['[6, 12]']]
-  end
-
-  it 'can be limited to a specific number of captures', t:true do
-    values_for("2.times do\n1\nend", number_of_captures: 1)
-      .should == [['2'],
-                  ['1', '...'],
-                  ['2']]
+    expect(values_for("1 +\n2")).to eq [['1'], ['3']]
+    expect(values_for("1\\\n+ 2")).to eq [['1'], ['3']]
+    expect(values_for("[*1..5]
+                        .select(&:even?)
+                        .map { |n| n * 3 }")).to eq [['[1, 2, 3, 4, 5]'],
+                                                     ['[2, 4]'],
+                                                     ['[6, 12]']]
+    expect(values_for("[*1..5]
+                        .select(&:even?)
+                        .map { |n| n * 2 }.
+                        map  { |n| n / 2 }\\
+                        .map { |n| n * 3 }")).to eq [['[1, 2, 3, 4, 5]'],
+                                                        ['[2, 4]'],
+                                                        ['[4, 8]'],
+                                                        ['[2, 4]'],
+                                                        ['[6, 12]']]
+  end
+
+  it 'can be limited to a specific number of captures' do
+    expect(values_for "2.times do\n1\nend", number_of_captures: 1).to \
+      eq [['2'],
+          ['1', '...'],
+          ['2']]
   end
 
   it 'can evaluate under a different ruby executable' do
@@ -320,14 +325,14 @@ describe SeeingIsBelieving do
         result = SeeingIsBelieving::Result.new
         result.record_result(1, /omg/)
 
-        require 'yaml'
-        puts YAML.dump result
+        require 'json'
+        puts JSON.dump result.to_primitive
       "
       File.chmod 0755, 'omg-ruby'
       old_path = ENV['PATH']
       ENV['PATH'] = "#{proving_grounds_dir}:#{old_path}"
       begin
-        values_for("1", ruby_executable: 'omg-ruby').should == [["/omg/"]]
+        expect(values_for("1", ruby_executable: 'omg-ruby')).to eq [["/omg/"]]
       ensure
         ENV['PATH'] = old_path
       end
@@ -335,21 +340,39 @@ describe SeeingIsBelieving do
   end
 
   it 'does not record BEGIN and END', not_implemented: true do
-    pending 'not implemented' do
-      expect { invoke <<-CODE }.to_not raise_error
-        puts 1
-        BEGIN {
-          puts "begin code"
-          some_var = 2
-        }
-        puts 3
-        END {
-          puts "end code"
-          puts some_var
-        }
-        puts 4
-      CODE
-    end
+    pending 'not implemented'
+    expect { invoke <<-CODE }.to_not raise_error
+      puts 1
+      BEGIN {
+        puts "begin code"
+        some_var = 2
+      }
+      puts 3
+      END {
+        puts "end code"
+        puts some_var
+      }
+      puts 4
+    CODE
+  end
+
+  # For more info about this one
+  # https://github.com/JoshCheek/seeing_is_believing/issues/24
+  it 'does not blow up when executing commands that bypass stdout and talk directly to low-level stdout fd (e.g. C\'s system command from stdlib.h)' do
+    expect(invoke(%q[system "ruby -e '$stdout.print ?a'"]).stdout).to eq "a"
+    expect(invoke(%q[system "ruby -e '$stderr.print ?a'"]).stderr).to eq "a"
+  end
+
+  it 'does not blow up when inspect recurses infinitely' do
+    result = invoke(%[def self.inspect
+                        self
+                      end
+                      self], filename: 'blowsup.rb')
+    expect(result).to have_exception
+    expect(result.exception.class_name).to eq 'SystemStackError'
+    expect(result.exception.backtrace.grep(/blowsup.rb/)).to_not be_empty # backtrace includes a line that we can show
+    expect(result.exception.message).to match /recursive/i
+    expect(result[4].exception).to eq result.exception
   end
 
   context 'when given a debugger' do
@@ -362,14 +385,14 @@ describe SeeingIsBelieving do
 
     it 'prints the pre-evaluated program' do
       call
-      stream.string.should include "TRANSLATED PROGRAM:"
-      stream.string.should include "\nbegin;" # there is more, but we're just interested in showing that it wound up in the stream
+      expect(stream.string).to include "TRANSLATED PROGRAM:"
+      expect(stream.string).to include "\nbegin;" # there is more, but we're just interested in showing that it wound up in the stream
     end
 
     it 'prints the result' do
       call
-      stream.string.should include "RESULT:"
-      stream.string.should include '1=>#<SIB:Line["1"] (1, 1) no exception>'
+      expect(stream.string).to include "RESULT:"
+      expect(stream.string).to include '1=>#<SIB:Line["1"] (1, 1) no exception>'
     end
     # should ProgramRewriter have some debug options?
   end