seeing_is_believing 2.1.3 → 2.1.4

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+# RSpec.configure do |c|
+#   c.disable_monkey_patching!
+# end

data/spec/wrap_expressions_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'seeing_is_believing/wrap_expressions'
 
 describe SeeingIsBelieving::WrapExpressions do
@@ -12,7 +13,7 @@ describe SeeingIsBelieving::WrapExpressions do
   end
 
   it 'can inject syntax errors with __TOTAL_FUCKING_FAILURE__' do
-    wrap('__TOTAL_FUCKING_FAILURE__').should == '<.....TOTAL FUCKING FAILURE!.....>'
+    expect(wrap('__TOTAL_FUCKING_FAILURE__')).to eq '<.....TOTAL FUCKING FAILURE!.....>'
   end
 
   describe 'wrapping the body' do
@@ -22,25 +23,25 @@ describe SeeingIsBelieving::WrapExpressions do
                       after_each:  -> * { '>' } } }
 
     it 'wraps the entire body, ignoring leading comments and the data segment' do
-      described_class.call("#comment\nA\n__END__\n1", options).should == "#comment\n[<A>]\n__END__\n1"
+      expect(described_class.call("#comment\nA\n__END__\n1", options)).to eq "#comment\n[<A>]\n__END__\n1"
     end
 
     it 'does nothing when there are only comments' do
-      described_class.call("# abc", options).should == "# abc"
+      expect(described_class.call("# abc", options)).to eq "# abc"
     end
 
     it 'comes in before trailing comments' do
-      described_class.call("1# abc", options).should == "[<1>]# abc"
+      expect(described_class.call("1# abc", options)).to eq "[<1>]# abc"
     end
 
     it 'wraps bodies that are wrapped in parentheses' do
-      wrap('(1)').should == '<(1)>'
-      wrap("(\n<<doc\ndoc\n)").should == "<(\n<<<doc>\ndoc\n)>"
+      expect(wrap('(1)')).to eq '<(1)>'
+      expect(wrap("(\n<<doc\ndoc\n)")).to eq "<(\n<<<doc>\ndoc\n)>"
     end
 
     context 'fucking heredocs' do
       example 'single heredoc' do
-        described_class.call("<<A\nA", options).should == "[<<<A>]\nA"
+        expect(described_class.call("<<A\nA", options)).to eq "[<<<A>]\nA"
       end
 
       example 'multiple heredocs' do
@@ -50,18 +51,30 @@ describe SeeingIsBelieving::WrapExpressions do
         # "[<<<<A>\nA\n<<B>]\nB"
         # instead of
         # "[<<<A>\nA\n<<<B>]\nB"
-        described_class.call("<<A\nA\n<<B\nB", options).should == "[<<<<A>\nA\n<<B>]\nB"
+        expect(described_class.call("<<A\nA\n<<B\nB", options)).to eq "[<<<<A>\nA\n<<B>]\nB"
       end
 
       example 'heredocs as targets and arguments to methods' do
-        described_class.call("<<A.size 1\nA", options).should == "[<<<A.size 1>]\nA"
-        described_class.call("<<A.size\nA", options).should == "[<<<A.size>]\nA"
-        described_class.call("<<A.size()\nA", options).should == "[<<<A.size()>]\nA"
-        described_class.call("a.size <<A\nA", options).should == "[<a.size <<A>]\nA"
-        described_class.call("<<A.size <<B\nA\nB", options).should == "[<<<A.size <<B>]\nA\nB"
-        described_class.call("<<A.size(<<B)\nA\nB", options).should == "[<<<A.size(<<B)>]\nA\nB"
+        expect(described_class.call("<<A.size 1\nA", options)).to eq "[<<<A.size 1>]\nA"
+        expect(described_class.call("<<A.size\nA", options)).to eq "[<<<A.size>]\nA"
+        expect(described_class.call("<<A.size()\nA", options)).to eq "[<<<A.size()>]\nA"
+        expect(described_class.call("a.size <<A\nA", options)).to eq "[<a.size <<A>]\nA"
+        expect(described_class.call("<<A.size <<B\nA\nB", options)).to eq "[<<<A.size <<B>]\nA\nB"
+        expect(described_class.call("<<A.size(<<B)\nA\nB", options)).to eq "[<<<A.size(<<B)>]\nA\nB"
       end
     end
+
+    it 'identifies the last line of the body' do
+      expect(described_class.call("a\n"\
+                                  "def b\n"\
+                                  "  c = 1\n"\
+                                  "end",
+                                  options)
+            ).to eq "[<a>\n"\
+                    "def b\n"\
+                    "  <c = 1>\n"\
+                    "end]"
+    end
   end
 
   it 'passes the current line number to the before_each and after_each wrappers' do
@@ -70,20 +83,20 @@ describe SeeingIsBelieving::WrapExpressions do
                          before_each: -> _pre_line_num  { pre_line_num  = _pre_line_num;  '<' },
                          after_each:  -> _post_line_num { post_line_num = _post_line_num; '>' }
                         )
-    pre_line_num.should == 2
-    post_line_num.should == 2
+    expect(pre_line_num).to eq 2
+    expect(post_line_num).to eq 2
   end
 
   it 'does nothing for an empty program' do
-    wrap("").should == ""
-    wrap("\n").should == "\n"
+    expect(wrap("")).to eq ""
+    expect(wrap("\n")).to eq "\n"
   end
 
   it 'ignores comments' do
-    wrap("# comment").should == "# comment"
-    wrap("1 #abc\n#def").should == "<1> #abc\n#def"
-    wrap("1\n=begin\n2\n=end").should == "<1>\n=begin\n2\n=end"
-    wrap("=begin\n1\n=end\n2").should == "=begin\n1\n=end\n<2>"
+    expect(wrap "# comment"         ).to eq "# comment"
+    expect(wrap "1 #abc\n#def"      ).to eq "<1> #abc\n#def"
+    expect(wrap "1\n=begin\n2\n=end").to eq "<1>\n=begin\n2\n=end"
+    expect(wrap "=begin\n1\n=end\n2").to eq "=begin\n1\n=end\n<2>"
   end
 
   describe 'void value expressions' do
@@ -97,91 +110,91 @@ describe SeeingIsBelieving::WrapExpressions do
     end
 
     it 'knows a `return`, `next`, `redo`, `retry`, and `break` are void values' do
-      void_value?(ast_for("def a; return; end").children.last).should be_true
-      void_value?(ast_for("loop { next  }").children.last).should be_true
-      void_value?(ast_for("loop { redo  }").children.last).should be_true
-      void_value?(ast_for("loop { break }").children.last).should be_true
+      expect(void_value?(ast_for("def a; return; end").children.last)).to be true
+      expect(void_value?(ast_for("loop { next  }"    ).children.last)).to be true
+      expect(void_value?(ast_for("loop { redo  }"    ).children.last)).to be true
+      expect(void_value?(ast_for("loop { break }"    ).children.last)).to be true
 
       the_retry = ast_for("begin; rescue; retry; end").children.first.children[1].children.last
-      the_retry.type.should == :retry
-      void_value?(the_retry).should be_true
+      expect(the_retry.type).to eq :retry
+      expect(void_value? the_retry).to eq true
     end
     it 'knows an `if` is a void value if either side is a void value' do
       the_if = ast_for("def a; if 1; return 2; else; 3; end; end").children.last
-      the_if.type.should == :if
-      void_value?(the_if).should be_true
+      expect(the_if.type).to eq :if
+      expect(void_value?(the_if)).to be true
 
       the_if = ast_for("def a; if 1; 2; else; return 3; end; end").children.last
-      the_if.type.should == :if
-      void_value?(the_if).should be_true
+      expect(the_if.type).to eq :if
+      expect(void_value?(the_if)).to be true
 
       the_if = ast_for("def a; if 1; 2; else; 3; end; end").children.last
-      the_if.type.should == :if
-      void_value?(the_if).should be_false
+      expect(the_if.type).to eq :if
+      expect(void_value?(the_if)).to be false
     end
     it 'knows a begin is a void value if its last element is a void value' do
       the_begin = ast_for("loop { begin; break; end }").children.last
-      [:begin, :kwbegin].should include the_begin.type
-      void_value?(the_begin).should be_true
+      expect([:begin, :kwbegin]).to include the_begin.type
+      expect(void_value?(the_begin)).to be true
 
       the_begin = ast_for("loop { begin; 1; end }").children.last
-      [:begin, :kwbegin].should include the_begin.type
-      void_value?(the_begin).should be_false
+      expect([:begin, :kwbegin]).to include the_begin.type
+      expect(void_value?(the_begin)).to be false
     end
     it 'knows a rescue is a void value if its last child or its else is a void value' do
       the_rescue = ast_for("begin; rescue; retry; end").children.first
-      the_rescue.type.should == :rescue
-      void_value?(the_rescue).should be_true
+      expect(the_rescue.type).to eq :rescue
+      expect(void_value?(the_rescue)).to be true
 
       the_rescue = ast_for("begin; rescue; 1; else; retry; end").children.first
-      the_rescue.type.should == :rescue
-      void_value?(the_rescue).should be_true
+      expect(the_rescue.type).to eq :rescue
+      expect(void_value?(the_rescue)).to be true
 
       the_rescue = ast_for("begin; rescue; 1; else; 2; end").children.first
-      the_rescue.type.should == :rescue
-      void_value?(the_rescue).should be_false
+      expect(the_rescue.type).to eq :rescue
+      expect(void_value?(the_rescue)).to be false
     end
     it 'knows an ensure is a void value if its body or ensure portion are void values' do
       the_ensure = ast_for("loop { begin; break; ensure; 1; end }").children.last.children.last
-      the_ensure.type.should == :ensure
-      void_value?(the_ensure).should be_true
+      expect(the_ensure.type).to eq :ensure
+      expect(void_value?(the_ensure)).to be true
 
       the_ensure = ast_for("loop { begin; 1; ensure; break; end }").children.last.children.last
-      the_ensure.type.should == :ensure
-      void_value?(the_ensure).should be_true
+      expect(the_ensure.type).to eq :ensure
+      expect(void_value?(the_ensure)).to be true
 
       the_ensure = ast_for("loop { begin; 1; ensure; 2; end }").children.last.children.last
-      the_ensure.type.should == :ensure
-      void_value?(the_ensure).should be_false
+      expect(the_ensure.type).to eq :ensure
+      expect(void_value?(the_ensure)).to be false
     end
     it 'knows other things are not void values' do
-      void_value?(ast_for "123").should be_false
+      expect(void_value?(ast_for "123")).to be false
     end
   end
 
   describe 'basic expressions' do
     it 'wraps an expression' do
-      wrap("A").should == "<A>"
+      expect(wrap("A")).to eq "<A>"
     end
 
     it 'wraps multiple expressions' do
-      wrap("A\nB").should == "<A>\n<B>"
-      wrap("(1\n2)").should == "<(<1>\n2)>"
-      wrap("(1\n2\n)").should == "<(<1>\n<2>\n)>"
-      wrap("begin\n1\n2\nend").should == "<begin\n<1>\n<2>\nend>"
+      expect(wrap("A\nB")).to eq "<A>\n<B>"
+      expect(wrap("(1\n2)")).to eq "<(<1>\n2)>"
+      expect(wrap("(1\n2\n)")).to eq "<(<1>\n<2>\n)>"
+      expect(wrap("begin\n1\n2\nend")).to eq "<begin\n<1>\n<2>\nend>"
     end
 
     it 'does not wrap multiple expressions when they constitute a void value' do
-      wrap("def a\n1\nreturn 2\nend").should == "def a\n<1>\nreturn <2>\nend"
-      wrap("def a\nreturn 1\n2\nend").should == "def a\nreturn <1>\n<2>\nend"
+      expect(wrap("def a\n1\nreturn 2\nend")).to eq "def a\n<1>\nreturn <2>\nend"
+      expect(wrap("def a\nreturn 1\n2\nend")).to eq "def a\nreturn <1>\n<2>\nend"
     end
 
     it 'wraps nested expressions' do
-      wrap("A do\nB\nend").should == "<A do\n<B>\nend>"
+      expect(wrap("A do\nB\nend")).to eq "<A do\n<B>\nend>"
     end
 
     it 'wraps multiple expressions on the same line' do
-      wrap("a;b").should == "a;<b>"
+      expect(wrap("a;b")).to eq "a;<b>"
     end
 
     # many of these taken from http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Literals
@@ -237,447 +250,500 @@ describe SeeingIsBelieving::WrapExpressions do
       |.each do |literal|
         actual   = wrap(literal)
         expected = "<#{literal}>"
-        actual.should eq(expected), "expected #{literal.inspect} to equal #{expected.inspect}, got #{actual.inspect}"
+        expect(actual).to eq(expected), "expected #{literal.inspect} to equal #{expected.inspect}, got #{actual.inspect}"
       end
     end
 
     it 'wraps macros' do
       # should this actually replace __FILE__ and __LINE__ so as to avoid fucking up values with the rewrite?
       # there is also __dir__, but it's only 2.0
-      wrap("__FILE__").should == "<__FILE__>"
-      wrap("__LINE__").should == "<__LINE__>"
-      wrap("defined? a").should == "<defined? a>"
+      expect(wrap("__FILE__")).to eq "<__FILE__>"
+      expect(wrap("__LINE__")).to eq "<__LINE__>"
+      expect(wrap("defined? a")).to eq "<defined? a>"
     end
 
     it 'does not wrap alias, undef' do
-      wrap("alias tos to_s").should == "alias tos to_s"
-      wrap("undef tos").should == "undef tos"
+      expect(wrap("alias tos to_s")).to eq "alias tos to_s"
+      expect(wrap("undef tos")).to eq "undef tos"
     end
 
     it 'wraps syscalls, but not code interpolated into them' do
-      wrap("`a\nb`").should == "<`a\nb`>"
-      wrap("`a\n\#{1\n2\n3}b`").should == "<`a\n\#{1\n2\n3}b`>"
+      expect(wrap("`a\nb`")).to eq "<`a\nb`>"
+      expect(wrap("`a\n\#{1\n2\n3}b`")).to eq "<`a\n\#{1\n2\n3}b`>"
     end
   end
 
   describe 'variable lookups' do
     it 'wraps them' do
-      wrap('a').should == "<a>"
-      wrap("$a").should == "<$a>"
-      wrap("@a").should == "<@a>"
-      wrap("@@a").should == "<@@a>"
+      expect(wrap('a')).to eq "<a>"
+      expect(wrap("$a")).to eq "<$a>"
+      expect(wrap("@a")).to eq "<@a>"
+      expect(wrap("@@a")).to eq "<@@a>"
     end
   end
 
   describe 'method invocations' do
     it 'wraps the whole invocation with or without parens' do
-      wrap("a").should == "<a>"
-      wrap("a()").should == "<a()>"
-      wrap("a()").should == "<a()>"
+      expect(wrap("a")).to eq "<a>"
+      expect(wrap("a()")).to eq "<a()>"
+      expect(wrap("a()")).to eq "<a()>"
     end
 
     it 'does not wrap arguments' do
-      wrap("a b").should == "<a b>"
-      wrap("a(b,c=1,*d,&e)").should == "<a(b,c=1,*d,&e)>"
+      expect(wrap("a b")).to eq "<a b>"
+      expect(wrap("a(b,c=1,*d,&e)")).to eq "<a(b,c=1,*d,&e)>"
     end
 
     it 'wraps blocks' do
-      wrap("a { }").should == "<a { }>"
-      wrap("a {\n}").should == "<a {\n}>"
-      wrap("a(b) {\n}").should == "<a(b) {\n}>"
+      expect(wrap("a { }")).to eq "<a { }>"
+      expect(wrap("a {\n}")).to eq "<a {\n}>"
+      expect(wrap("a(b) {\n}")).to eq "<a(b) {\n}>"
     end
 
     it 'wraps method calls with an explicit receiver' do
-      wrap("1.mod(2)").should == "<1.mod(2)>"
-      wrap("1.mod 2").should == "<1.mod 2>"
+      expect(wrap("1.mod(2)")).to eq "<1.mod(2)>"
+      expect(wrap("1.mod 2")).to eq "<1.mod 2>"
     end
 
     it 'wraps operators calls' do
-      wrap("1+1").should == "<1+1>"
-      wrap("a.b+1").should == "<a.b+1>"
-      wrap("a.b - 1").should == "<a.b - 1>"
-      wrap("a.b -1").should == "<a.b -1>"
-      wrap("!1").should == "<!1>"
-      wrap("~1").should == "<~1>"
+      expect(wrap("1+1")).to eq "<1+1>"
+      expect(wrap("a.b+1")).to eq "<a.b+1>"
+      expect(wrap("a.b - 1")).to eq "<a.b - 1>"
+      expect(wrap("a.b -1")).to eq "<a.b -1>"
+      expect(wrap("!1")).to eq "<!1>"
+      expect(wrap("~1")).to eq "<~1>"
     end
 
     it 'wraps methods that end in bangs and questions' do
-      wrap("a.b!").should == "<a.b!>"
-      wrap("a.b?").should == "<a.b?>"
+      expect(wrap("a.b!")).to eq "<a.b!>"
+      expect(wrap("a.b?")).to eq "<a.b?>"
     end
 
     it 'wraps method invocations that span multiple lines' do
-      wrap("a\n.b\n.c").should == "<<<a>\n.b>\n.c>"
-      wrap("a\n.b{\n}").should == "<<a>\n.b{\n}>"
-      wrap("a\n.b{}").should == "<<a>\n.b{}>"
-      wrap("[*1..5]\n.map { |n| n * 2 }\n.take(2).\nsize").should ==
+      expect(wrap("a\n.b\n.c")).to eq "<<<a>\n.b>\n.c>"
+      expect(wrap("a\n.b{\n}")).to eq "<<a>\n.b{\n}>"
+      expect(wrap("a\n.b{}")).to eq "<<a>\n.b{}>"
+      expect(wrap("[*1..5]\n.map { |n| n * 2 }\n.take(2).\nsize")).to eq\
         "<<<<[*1..5]>\n.map { |n| n * 2 }>\n.take(2)>.\nsize>"
-      wrap("a = b\n.c\na").should == "<a = <b>\n.c>\n<a>"
+      expect(wrap("a = b\n.c\na")).to eq "<a = <b>\n.c>\n<a>"
     end
 
     it 'wraps args in method arguments when the method spans multiple lines' do
-      wrap("a 1,\n2").should == "<a <1>,\n2>"
+      expect(wrap("a 1,\n2")).to eq "<a <1>,\n2>"
     end
 
     it 'does not wrap splat args' do
-      wrap("a(\n*a\n)").should == "<a(\n*a\n)>"
-      wrap("a(\n*1..2\n)").should == "<a(\n*1..2\n)>"
+      expect(wrap("a(\n*a\n)")).to eq "<a(\n*a\n)>"
+      expect(wrap("a(\n*1..2\n)")).to eq "<a(\n*1..2\n)>"
     end
 
     it 'does not wrap hash args' do
-      wrap("a(b: 1,\nc: 2\n)").should == "<a(b: <1>,\nc: <2>\n)>"
+      expect(wrap("a(b: 1,\nc: 2\n)")).to eq "<a(b: <1>,\nc: <2>\n)>"
     end
   end
 
   describe 'assignment' do
     it 'wraps entire simple assignment' do
-      wrap("a=1").should == "<a=1>"
-      wrap("a.b=1").should == "<a.b=1>"
-      wrap("A=1").should == "<A=1>"
-      wrap("::A=1").should == "<::A=1>"
-      wrap("A::B=1").should == "<A::B=1>"
-      wrap("@a=1").should == "<@a=1>"
-      wrap("@@a=1").should == "<@@a=1>"
-      wrap("$a=1").should == "<$a=1>"
+      expect(wrap("a=1")).to eq "<a=1>"
+      expect(wrap("a.b=1")).to eq "<a.b=1>"
+      expect(wrap("A=1")).to eq "<A=1>"
+      expect(wrap("::A=1")).to eq "<::A=1>"
+      expect(wrap("A::B=1")).to eq "<A::B=1>"
+      expect(wrap("@a=1")).to eq "<@a=1>"
+      expect(wrap("@@a=1")).to eq "<@@a=1>"
+      expect(wrap("$a=1")).to eq "<$a=1>"
     end
 
     it 'wraps multiple assignments' do
-      wrap("a,b=c").should == "<a,b=c>"
-      wrap("a,b=1,2").should == "<a,b=1,2>"
-      wrap("a,b.c=1,2").should == "<a,b.c=1,2>"
-      wrap("a,B=1,2").should == "<a,B=1,2>"
-      wrap("a,B::C=1,2").should == "<a,B::C=1,2>"
-      wrap("a,@b=1,2").should == "<a,@b=1,2>"
-      wrap("a,@@b=1,2").should == "<a,@@b=1,2>"
-      wrap("a,$b=1,2").should == "<a,$b=1,2>"
-      wrap("a, b = x.()").should == "<a, b = x.()>"
-      wrap("a, b = c\n.d,\ne\n.f").should == "<a, b = <<c>\n.d>,\n<e>\n.f>"
+      expect(wrap("a,b=c")).to eq "<a,b=c>"
+      expect(wrap("a,b=1,2")).to eq "<a,b=1,2>"
+      expect(wrap("a,b.c=1,2")).to eq "<a,b.c=1,2>"
+      expect(wrap("a,B=1,2")).to eq "<a,B=1,2>"
+      expect(wrap("a,B::C=1,2")).to eq "<a,B::C=1,2>"
+      expect(wrap("a,@b=1,2")).to eq "<a,@b=1,2>"
+      expect(wrap("a,@@b=1,2")).to eq "<a,@@b=1,2>"
+      expect(wrap("a,$b=1,2")).to eq "<a,$b=1,2>"
+      expect(wrap("a, b = x.()")).to eq "<a, b = x.()>"
+      expect(wrap("a, b = c\n.d,\ne\n.f")).to eq "<a, b = <<c>\n.d>,\n<e>\n.f>"
     end
 
     it 'wraps multiple assignment on each line' do
-      wrap("a,b=1,\n2").should == "<a,b=<1>,\n2>"
-      wrap("a,b=[1,2]\n.map(&:to_s)").should == "<a,b=<[1,2]>\n.map(&:to_s)>"
-      wrap("a,b=[1,\n2\n.even?\n]").should == "<a,b=[<1>,\n<<2>\n.even?>\n]>"
+      expect(wrap("a,b=1,\n2")).to eq "<a,b=<1>,\n2>"
+      expect(wrap("a,b=[1,2]\n.map(&:to_s)")).to eq "<a,b=<[1,2]>\n.map(&:to_s)>"
+      expect(wrap("a,b=[1,\n2\n.even?\n]")).to eq "<a,b=[<1>,\n<<2>\n.even?>\n]>"
     end
 
     it 'wraps multiple assignment with splats' do
-      wrap("a,* =1,2,3").should == "<a,* =1,2,3>"
+      expect(wrap("a,* =1,2,3")).to eq "<a,* =1,2,3>"
     end
 
     it 'wraps the array equivalent' do
-      wrap("a,* =[1,2,3]").should == "<a,* =[1,2,3]>"
-      wrap("a,* = [ 1,2,3 ] ").should == "<a,* = [ 1,2,3 ]> "
+      expect(wrap("a,* =[1,2,3]")).to eq "<a,* =[1,2,3]>"
+      expect(wrap("a,* = [ 1,2,3 ] ")).to eq "<a,* = [ 1,2,3 ]> "
     end
 
     it 'wraps repeated assignments' do
-      wrap("a=b=1").should == "<a=b=1>"
-      wrap("a=b=\n1").should == "<a=b=\n1>"
-      wrap("a=\nb=\n1").should == "<a=\nb=\n1>"
+      expect(wrap("a=b=1")).to eq "<a=b=1>"
+      expect(wrap("a=b=\n1")).to eq "<a=b=\n1>"
+      expect(wrap("a=\nb=\n1")).to eq "<a=\nb=\n1>"
     end
 
     it 'wraps operator assignment' do
-      wrap("a += 1").should == "<a += 1>"
-      wrap("a *= 1").should == "<a *= 1>"
-      wrap("a -= 1").should == "<a -= 1>"
-      wrap("a /= 1").should == "<a /= 1>"
-      wrap("a **= 1").should == "<a **= 1>"
-      wrap("a |= 1").should == "<a |= 1>"
-      wrap("a &= 1").should == "<a &= 1>"
-      wrap("a ||= 1").should == "<a ||= 1>"
-      wrap("a &&= 1").should == "<a &&= 1>"
-      wrap("a[1] = 2").should == "<a[1] = 2>"
-      wrap("a[1] ||= 2").should == "<a[1] ||= 2>"
-      wrap("@a  ||= 123").should == "<@a  ||= 123>"
-      wrap("$a  ||= 123").should == "<$a  ||= 123>"
-      wrap("@@a ||= 123").should == "<@@a ||= 123>"
-      wrap("B   ||= 123").should == "<B   ||= 123>"
-      wrap("@a  ||= begin\n123\nend").should == "<@a  ||= begin\n<123>\nend>"
-      wrap("$a  ||= begin\n123\nend").should == "<$a  ||= begin\n<123>\nend>"
-      wrap("@@a ||= begin\n123\nend").should == "<@@a ||= begin\n<123>\nend>"
-      wrap("B   ||= begin\n123\nend").should == "<B   ||= begin\n<123>\nend>"
+      expect(wrap("a += 1")).to eq "<a += 1>"
+      expect(wrap("a *= 1")).to eq "<a *= 1>"
+      expect(wrap("a -= 1")).to eq "<a -= 1>"
+      expect(wrap("a /= 1")).to eq "<a /= 1>"
+      expect(wrap("a **= 1")).to eq "<a **= 1>"
+      expect(wrap("a |= 1")).to eq "<a |= 1>"
+      expect(wrap("a &= 1")).to eq "<a &= 1>"
+      expect(wrap("a ||= 1")).to eq "<a ||= 1>"
+      expect(wrap("a &&= 1")).to eq "<a &&= 1>"
+      expect(wrap("a[1] = 2")).to eq "<a[1] = 2>"
+      expect(wrap("a[1] ||= 2")).to eq "<a[1] ||= 2>"
+      expect(wrap("@a  ||= 123")).to eq "<@a  ||= 123>"
+      expect(wrap("$a  ||= 123")).to eq "<$a  ||= 123>"
+      expect(wrap("@@a ||= 123")).to eq "<@@a ||= 123>"
+      expect(wrap("B   ||= 123")).to eq "<B   ||= 123>"
+      expect(wrap("@a  ||= begin\n123\nend")).to eq "<@a  ||= begin\n<123>\nend>"
+      expect(wrap("$a  ||= begin\n123\nend")).to eq "<$a  ||= begin\n<123>\nend>"
+      expect(wrap("@@a ||= begin\n123\nend")).to eq "<@@a ||= begin\n<123>\nend>"
+      expect(wrap("B   ||= begin\n123\nend")).to eq "<B   ||= begin\n<123>\nend>"
+    end
+
+    it 'wraps assignments that span multiple lines' do
+      # simple assignment
+      expect(wrap("a={\n}")).to eq "<a={\n}>"
+      expect(wrap("a, b = c,{\n}")).to eq "<a, b = <c>,{\n}>"
+      expect(wrap("a.b={\n}")).to eq "<<a>.b={\n}>"
+      expect(wrap("A={\n}")).to eq "<A={\n}>"
+      expect(wrap("::A={\n}")).to eq "<::A={\n}>"
+      expect(wrap("A::B={\n}")).to eq "<A::B={\n}>"
+      expect(wrap("@a={\n}")).to eq "<@a={\n}>"
+      expect(wrap("@@a={\n}")).to eq "<@@a={\n}>"
+      expect(wrap("$a={\n}")).to eq "<$a={\n}>"
+
+      # multiple assignment
+      expect(wrap("a,b={\n}")).to eq "<a,b={\n}>"
+      expect(wrap("a,b={\n},{\n}")).to eq "<a,b=<{\n}>,{\n}>"
+      expect(wrap("a,b.c={\n},{\n}")).to eq "<a,b.c=<{\n}>,{\n}>"
+      expect(wrap("a,B={\n},{\n}")).to eq "<a,B=<{\n}>,{\n}>"
+      expect(wrap("a,B::C={\n},{\n}")).to eq "<a,B::C=<{\n}>,{\n}>"
+      expect(wrap("a,@b={\n},{\n}")).to eq "<a,@b=<{\n}>,{\n}>"
+      expect(wrap("a,@@b={\n},{\n}")).to eq "<a,@@b=<{\n}>,{\n}>"
+      expect(wrap("a,$b={\n},{\n}")).to eq "<a,$b=<{\n}>,{\n}>"
+
+      # repeated assignments
+      expect(wrap("a=\nb={\n}")).to eq "<a=\nb={\n}>"
+
+      # operator assignment
+      expect(wrap("a +={\n}")).to eq "<a +={\n}>"
+      expect(wrap("a *= {\n}")).to eq "<a *= {\n}>"
+      expect(wrap("a -= {\n}")).to eq "<a -= {\n}>"
+      expect(wrap("a /= {\n}")).to eq "<a /= {\n}>"
+      expect(wrap("a **= {\n}")).to eq "<a **= {\n}>"
+      expect(wrap("a |= {\n}")).to eq "<a |= {\n}>"
+      expect(wrap("a &= {\n}")).to eq "<a &= {\n}>"
+      expect(wrap("a ||= {\n}")).to eq "<a ||= {\n}>"
+      expect(wrap("a &&= {\n}")).to eq "<a &&= {\n}>"
+      expect(wrap("a[1] = {\n}")).to eq "<a[<1>] = {\n}>"
+      expect(wrap("a[1]   ||= {\n}")).to eq "<a[1]   ||= {\n}>"
+      expect(wrap("@a     ||= {\n}")).to eq "<@a     ||= {\n}>"
+      expect(wrap("$a     ||= {\n}")).to eq "<$a     ||= {\n}>"
+      expect(wrap("@@a    ||= {\n}")).to eq "<@@a    ||= {\n}>"
+      expect(wrap("B      ||= {\n}")).to eq "<B      ||= {\n}>"
+      expect(wrap("{}[:a] ||= {\n}")).to eq "<{}[:a] ||= {\n}>"
+
+      # LHS with values in it on all the operator assignments
+      expect(wrap("a.b  += {\n}")).to eq "<a.b  += {\n}>"
+      expect(wrap("a.b  *= {\n}")).to eq "<a.b  *= {\n}>"
+      expect(wrap("a.b  -= {\n}")).to eq "<a.b  -= {\n}>"
+      expect(wrap("a.b  /= {\n}")).to eq "<a.b  /= {\n}>"
+      expect(wrap("a.b **= {\n}")).to eq "<a.b **= {\n}>"
+      expect(wrap("a.b  |= {\n}")).to eq "<a.b  |= {\n}>"
+      expect(wrap("a.b  &= {\n}")).to eq "<a.b  &= {\n}>"
+      expect(wrap("a.b &&= {\n}")).to eq "<a.b &&= {\n}>"
     end
 
     it 'wraps arguments in the assignment' do
-      wrap("a[1\n]=2").should == "<a[<1>\n]=2>"
-      wrap("a[1,\n2\n]=3").should == "<a[<1>,\n<2>\n]=3>"
+      expect(wrap("a[1\n]=2")).to eq "<a[<1>\n]=2>"
+      expect(wrap("a[1,\n2\n]=3")).to eq "<a[<1>,\n<2>\n]=3>"
     end
   end
 
   describe 'conditionals' do
     it 'wraps if/elsif/else/end, the whole thing, their conditionals, and their bodies' do
-      wrap("if 1\n2\nelsif 2\n3\nelsif 4\n5\nend").should == "<if <1>\n<2>\nelsif <2>\n<3>\nelsif <4>\n<5>\nend>" # multiple elsif
-      wrap("if 1\n2\nelsif 2\n3\nelse\n4\nend").should == "<if <1>\n<2>\nelsif <2>\n<3>\nelse\n<4>\nend>"         # elisf and else
-      wrap("if 1\n2\nelsif 3\n4\nend").should == "<if <1>\n<2>\nelsif <3>\n<4>\nend>"                             # elsif only
-      wrap("if 1\n2\nelse\n2\nend").should == "<if <1>\n<2>\nelse\n<2>\nend>"                                     # else only
-      wrap("if 1\n2\nend").should == "<if <1>\n<2>\nend>"                                                         # if only
+      expect(wrap("if 1\n2\nelsif 2\n3\nelsif 4\n5\nend")).to eq "<if <1>\n<2>\nelsif <2>\n<3>\nelsif <4>\n<5>\nend>" # multiple elsif
+      expect(wrap("if 1\n2\nelsif 2\n3\nelse\n4\nend")).to eq "<if <1>\n<2>\nelsif <2>\n<3>\nelse\n<4>\nend>"         # elisf and else
+      expect(wrap("if 1\n2\nelsif 3\n4\nend")).to eq "<if <1>\n<2>\nelsif <3>\n<4>\nend>"                             # elsif only
+      expect(wrap("if 1\n2\nelse\n2\nend")).to eq "<if <1>\n<2>\nelse\n<2>\nend>"                                     # else only
+      expect(wrap("if 1\n2\nend")).to eq "<if <1>\n<2>\nend>"                                                         # if only
 
       # same as above, but with then
-      wrap("if 1 then\n2\nelsif 2 then\n3\nelsif 4 then\n5\nend").should == "<if <1> then\n<2>\nelsif <2> then\n<3>\nelsif <4> then\n<5>\nend>"
-      wrap("if 1 then\n2\nelsif 2 then\n3\nelse\n4\nend").should == "<if <1> then\n<2>\nelsif <2> then\n<3>\nelse\n<4>\nend>"
-      wrap("if 1 then\n2\nelsif 3 then\n4\nend").should == "<if <1> then\n<2>\nelsif <3> then\n<4>\nend>"
-      wrap("if 1 then\n2\nelse\n2\nend").should == "<if <1> then\n<2>\nelse\n<2>\nend>"
-      wrap("if 1 then\n2\nend").should == "<if <1> then\n<2>\nend>"
+      expect(wrap("if 1 then\n2\nelsif 2 then\n3\nelsif 4 then\n5\nend")).to eq "<if <1> then\n<2>\nelsif <2> then\n<3>\nelsif <4> then\n<5>\nend>"
+      expect(wrap("if 1 then\n2\nelsif 2 then\n3\nelse\n4\nend")).to eq "<if <1> then\n<2>\nelsif <2> then\n<3>\nelse\n<4>\nend>"
+      expect(wrap("if 1 then\n2\nelsif 3 then\n4\nend")).to eq "<if <1> then\n<2>\nelsif <3> then\n<4>\nend>"
+      expect(wrap("if 1 then\n2\nelse\n2\nend")).to eq "<if <1> then\n<2>\nelse\n<2>\nend>"
+      expect(wrap("if 1 then\n2\nend")).to eq "<if <1> then\n<2>\nend>"
 
       # inline
-      wrap("1 if 2").should == "<1 if 2>"
+      expect(wrap("1 if 2")).to eq "<1 if 2>"
     end
 
     it 'ignores conditionals that are implicit regexes' do
-      wrap("if /a/\n1\nend").should == "<if /a/\n<1>\nend>"
+      expect(wrap("if /a/\n1\nend")).to eq "<if /a/\n<1>\nend>"
     end
 
     it 'wraps ternaries' do
-      wrap("1 ? 2 : 3").should == "<1 ? 2 : 3>"
-      wrap("1\\\n?\\\n2\\\n:\\\n3").should == "<<1>\\\n?\\\n<2>\\\n:\\\n3>"
+      expect(wrap("1 ? 2 : 3")).to eq "<1 ? 2 : 3>"
+      expect(wrap("1\\\n?\\\n2\\\n:\\\n3")).to eq "<<1>\\\n?\\\n<2>\\\n:\\\n3>"
     end
 
     it 'wraps "unless" statements' do
-      wrap("unless 1\n2\nelse\n3\nend").should == "<unless <1>\n<2>\nelse\n<3>\nend>"
-      wrap("unless 1\n2\nend").should == "<unless <1>\n<2>\nend>"
-      wrap("unless 1 then\n2\nelse\n3\nend").should == "<unless <1> then\n<2>\nelse\n<3>\nend>"
-      wrap("unless 1 then\n2\nend").should == "<unless <1> then\n<2>\nend>"
-      wrap("1 unless 2").should == "<1 unless 2>"
+      expect(wrap("unless 1\n2\nelse\n3\nend")).to eq "<unless <1>\n<2>\nelse\n<3>\nend>"
+      expect(wrap("unless 1\n2\nend")).to eq "<unless <1>\n<2>\nend>"
+      expect(wrap("unless 1 then\n2\nelse\n3\nend")).to eq "<unless <1> then\n<2>\nelse\n<3>\nend>"
+      expect(wrap("unless 1 then\n2\nend")).to eq "<unless <1> then\n<2>\nend>"
+      expect(wrap("1 unless 2")).to eq "<1 unless 2>"
     end
 
     it 'wraps case statements, and the value they are initialized with, but not the conditionals' do
-      wrap("case 1\nwhen 2\n3\nwhen 4, 5\nelse\n6\nend").should == "<case <1>\nwhen 2\n<3>\nwhen 4, 5\nelse\n<6>\nend>"
-      wrap("case 1\nwhen 2\nend").should == "<case <1>\nwhen 2\nend>"
-      wrap("case\nwhen 2\nend").should == "<case\nwhen 2\nend>"
-      wrap("case\nwhen 2, 3\n4\n5\nend").should == "<case\nwhen 2, 3\n<4>\n<5>\nend>"
+      expect(wrap("case 1\nwhen 2\n3\nwhen 4, 5\nelse\n6\nend")).to eq "<case <1>\nwhen 2\n<3>\nwhen 4, 5\nelse\n<6>\nend>"
+      expect(wrap("case 1\nwhen 2\nend")).to eq "<case <1>\nwhen 2\nend>"
+      expect(wrap("case\nwhen 2\nend")).to eq "<case\nwhen 2\nend>"
+      expect(wrap("case\nwhen 2, 3\n4\n5\nend")).to eq "<case\nwhen 2, 3\n<4>\n<5>\nend>"
 
-      wrap("case 1\nwhen 2 then\n3\nwhen 4, 5 then\nelse\n6\nend").should == "<case <1>\nwhen 2 then\n<3>\nwhen 4, 5 then\nelse\n<6>\nend>"
-      wrap("case 1\nwhen 2 then\nend").should == "<case <1>\nwhen 2 then\nend>"
-      wrap("case\nwhen 2 then\nend").should == "<case\nwhen 2 then\nend>"
-      wrap("case\nwhen 2, 3 then\n4\n5\nend").should == "<case\nwhen 2, 3 then\n<4>\n<5>\nend>"
+      expect(wrap("case 1\nwhen 2 then\n3\nwhen 4, 5 then\nelse\n6\nend")).to eq "<case <1>\nwhen 2 then\n<3>\nwhen 4, 5 then\nelse\n<6>\nend>"
+      expect(wrap("case 1\nwhen 2 then\nend")).to eq "<case <1>\nwhen 2 then\nend>"
+      expect(wrap("case\nwhen 2 then\nend")).to eq "<case\nwhen 2 then\nend>"
+      expect(wrap("case\nwhen 2, 3 then\n4\n5\nend")).to eq "<case\nwhen 2, 3 then\n<4>\n<5>\nend>"
     end
 
     it 'does not wrap if the last value in any portion is a void value expression' do
-      wrap("def a\nif true\nreturn 1\nend\nend").should == "def a\nif <true>\nreturn <1>\nend\nend"
-      wrap("def a\nif true\n1\nelse\nreturn 2\nend\nend").should == "def a\nif <true>\n<1>\nelse\nreturn <2>\nend\nend"
-      wrap("def a\nif true\n1\nelsif true\n2\nelse\nreturn 3\nend\nend").should == "def a\nif <true>\n<1>\nelsif <true>\n<2>\nelse\nreturn <3>\nend\nend"
-      wrap("def a\nif true\nif true\nreturn 1\nend\nend\nend").should == "def a\nif <true>\nif <true>\nreturn <1>\nend\nend\nend"
-      wrap("def a\nunless true\nreturn 1\nend\nend").should == "def a\nunless <true>\nreturn <1>\nend\nend"
-      wrap("def a\nunless true\n1\nelse\nreturn 2\nend\nend").should == "def a\nunless <true>\n<1>\nelse\nreturn <2>\nend\nend"
-      wrap("def a\ntrue ?\n(return 1) :\n2\nend").should == "def a\n<true> ?\n(return <1>) :\n<2>\nend"
-      wrap("def a\ntrue ?\n1 :\n(return 2)\nend").should == "def a\n<true> ?\n<1> :\n(return <2>)\nend"
+      expect(wrap("def a\nif true\nreturn 1\nend\nend")).to eq "def a\nif <true>\nreturn <1>\nend\nend"
+      expect(wrap("def a\nif true\n1\nelse\nreturn 2\nend\nend")).to eq "def a\nif <true>\n<1>\nelse\nreturn <2>\nend\nend"
+      expect(wrap("def a\nif true\n1\nelsif true\n2\nelse\nreturn 3\nend\nend")).to eq "def a\nif <true>\n<1>\nelsif <true>\n<2>\nelse\nreturn <3>\nend\nend"
+      expect(wrap("def a\nif true\nif true\nreturn 1\nend\nend\nend")).to eq "def a\nif <true>\nif <true>\nreturn <1>\nend\nend\nend"
+      expect(wrap("def a\nunless true\nreturn 1\nend\nend")).to eq "def a\nunless <true>\nreturn <1>\nend\nend"
+      expect(wrap("def a\nunless true\n1\nelse\nreturn 2\nend\nend")).to eq "def a\nunless <true>\n<1>\nelse\nreturn <2>\nend\nend"
+      expect(wrap("def a\ntrue ?\n(return 1) :\n2\nend")).to eq "def a\n<true> ?\n(return <1>) :\n<2>\nend"
+      expect(wrap("def a\ntrue ?\n1 :\n(return 2)\nend")).to eq "def a\n<true> ?\n<1> :\n(return <2>)\nend"
     end
 
     # not sure if I actually want this, or if it's just easier b/c it falls out of the current implementation
     it 'wraps the conditional from an inline if, when it cannot wrap the entire if' do
-      wrap("def a\nreturn if 1\nend").should == "def a\nreturn if <1>\nend"
+      expect(wrap("def a\nreturn if 1\nend")).to eq "def a\nreturn if <1>\nend"
     end
 
     it 'does not wrap &&, and, ||, or, not' do
-      wrap("1\\\n&& 2").should == "<<1>\\\n&& 2>"
-      wrap("1\\\nand 2").should == "<<1>\\\nand 2>"
-      wrap("1\\\n|| 2").should == "<<1>\\\n|| 2>"
-      wrap("1\\\nor 2").should == "<<1>\\\nor 2>"
-      wrap("not\\\n1").should == "<not\\\n1>"
-      wrap("!\\\n1").should == "<!\\\n1>"
+      expect(wrap("1\\\n&& 2")).to eq "<<1>\\\n&& 2>"
+      expect(wrap("1\\\nand 2")).to eq "<<1>\\\nand 2>"
+      expect(wrap("1\\\n|| 2")).to eq "<<1>\\\n|| 2>"
+      expect(wrap("1\\\nor 2")).to eq "<<1>\\\nor 2>"
+      expect(wrap("not\\\n1")).to eq "<not\\\n1>"
+      expect(wrap("!\\\n1")).to eq "<!\\\n1>"
     end
   end
 
   describe 'loops' do
     it 'wraps the until condition and body' do
-      wrap("until 1\n2\nend").should == "<until <1>\n<2>\nend>"
-      wrap("1 until 2").should == "<1 until 2>"
-      wrap("begin\n1\nend until true").should == "<begin\n<1>\nend until true>"
+      expect(wrap("until 1\n2\nend")).to eq "<until <1>\n<2>\nend>"
+      expect(wrap("1 until 2")).to eq "<1 until 2>"
+      expect(wrap("begin\n1\nend until true")).to eq "<begin\n<1>\nend until true>"
     end
     it 'wraps the while condition and body' do
-      wrap("while 1\n2\nend").should == "<while <1>\n<2>\nend>"
-      wrap("1 while 2").should == "<1 while 2>"
-      wrap("begin\n1\nend while true").should == "<begin\n<1>\nend while true>"
+      expect(wrap("while 1\n2\nend")).to eq "<while <1>\n<2>\nend>"
+      expect(wrap("1 while 2")).to eq "<1 while 2>"
+      expect(wrap("begin\n1\nend while true")).to eq "<begin\n<1>\nend while true>"
     end
     it 'wraps for/in loops collections and bodies' do
-      wrap("for a in range;1;end").should == "<for a in range;1;end>"
-      wrap("for a in range\n1\nend").should == "<for a in <range>\n<1>\nend>"
-      wrap("for a in range do\n1\nend").should == "<for a in <range> do\n<1>\nend>"
-      wrap("for a,b in whatev\n1\nend").should == "<for a,b in <whatev>\n<1>\nend>"
+      expect(wrap("for a in range;1;end")).to eq "<for a in range;1;end>"
+      expect(wrap("for a in range\n1\nend")).to eq "<for a in <range>\n<1>\nend>"
+      expect(wrap("for a in range do\n1\nend")).to eq "<for a in <range> do\n<1>\nend>"
+      expect(wrap("for a,b in whatev\n1\nend")).to eq "<for a,b in <whatev>\n<1>\nend>"
       # this one just isn't worth it for now, too edge and I'm fucking tired
       # wrap("for char in <<HERE.each_char\nabc\nHERE\nputs char\nend").should ==
       #   "<for char in <<<HERE.each_char>\nabc\nHERE\n<puts char>\nend>"
     end
     it 'does not wrap redo' do
-      wrap("loop do\nredo\nend").should == "<loop do\nredo\nend>"
+      expect(wrap("loop do\nredo\nend")).to eq "<loop do\nredo\nend>"
     end
     it 'wraps the value of break' do
-      wrap("loop do\nbreak 1\nend").should == "<loop do\nbreak <1>\nend>"
+      expect(wrap("loop do\nbreak 1\nend")).to eq "<loop do\nbreak <1>\nend>"
     end
     it 'wraps the value of next' do
-      wrap("loop do\nnext 10\nend").should == "<loop do\nnext <10>\nend>"
+      expect(wrap("loop do\nnext 10\nend")).to eq "<loop do\nnext <10>\nend>"
     end
   end
 
   describe 'constant access' do
     it 'wraps simple constant access' do
-      wrap("A").should == "<A>"
+      expect(wrap("A")).to eq "<A>"
     end
 
     it 'wraps namespaced constant access' do
-      wrap("::A").should == "<::A>"
-      wrap("A::B").should == "<A::B>"
+      expect(wrap("::A")).to eq "<::A>"
+      expect(wrap("A::B")).to eq "<A::B>"
     end
   end
 
   describe 'hash literals' do
     it 'wraps the whole hash and values that are on their own lines' do
-      wrap("{}").should == "<{}>"
-      wrap("{\n1 => 2}").should == "<{\n1 => 2}>"
-      wrap("{\n1 => 2,\n:abc => 3,\ndef: 4\n}").should == "<{\n1 => <2>,\n:abc => <3>,\ndef: <4>\n}>"
+      expect(wrap("{}")).to eq "<{}>"
+      expect(wrap("{\n1 => 2}")).to eq "<{\n1 => 2}>"
+      expect(wrap("{\n1 => 2,\n:abc => 3,\ndef: 4\n}")).to eq "<{\n1 => <2>,\n:abc => <3>,\ndef: <4>\n}>"
     end
   end
 
   describe 'array literals' do
     it 'wraps the array and each element that is on its own line' do
-      wrap("[1]").should == "<[1]>"
-      wrap("[1,\n2,\n]").should == "<[<1>,\n<2>,\n]>"
-      wrap("[1, 2,\n]").should == "<[1, <2>,\n]>"
+      expect(wrap("[1]")).to eq "<[1]>"
+      expect(wrap("[1,\n2,\n]")).to eq "<[<1>,\n<2>,\n]>"
+      expect(wrap("[1, 2,\n]")).to eq "<[1, <2>,\n]>"
     end
 
     it 'does not wrap magic arrays' do
-      wrap("%w[\n1\n]").should == "<%w[\n1\n]>"
+      expect(wrap("%w[\n1\n]")).to eq "<%w[\n1\n]>"
     end
 
     it 'does not wrap splat elements' do
-      wrap("[1,\n*2..3,\n4\n]").should == "<[<1>,\n*2..3,\n<4>\n]>"
+      expect(wrap("[1,\n*2..3,\n4\n]")).to eq "<[<1>,\n*2..3,\n<4>\n]>"
     end
   end
 
   describe 'regex literals' do
     it 'wraps regexes' do
-      wrap("/a/").should == "</a/>"
-      wrap("/(?<a>x)/").should == "</(?<a>x)/>"
+      expect(wrap("/a/")).to eq "</a/>"
+      expect(wrap("/(?<a>x)/")).to eq "</(?<a>x)/>"
     end
 
     it 'wraps regexes with %r' do
-      wrap("%r(a)").should == "<%r(a)>"
-      wrap("%r'a'").should == "<%r'a'>"
+      expect(wrap("%r(a)")).to eq "<%r(a)>"
+      expect(wrap("%r'a'")).to eq "<%r'a'>"
     end
 
     it 'wraps regexes that span mulitple lines' do
-      wrap("/a\nb/").should == "</a\nb/>"
-      wrap("/a\nb/i").should == "</a\nb/i>"
+      expect(wrap("/a\nb/")).to eq "</a\nb/>"
+      expect(wrap("/a\nb/i")).to eq "</a\nb/i>"
     end
 
     # eventually it would be nice if it wraped the interpolated portion,
     # when the end of the line was not back inside the regexp
     it 'wraps regexes with interpolation, but not the interpolated portion' do
-      wrap("/a\#{1}/").should == "</a\#{1}/>"
-      wrap("/a\n\#{1}\nb/").should == "</a\n\#{1}\nb/>"
-      wrap("/a\n\#{1\n}b/").should == "</a\n\#{1\n}b/>"
+      expect(wrap("/a\#{1}/")).to eq "</a\#{1}/>"
+      expect(wrap("/a\n\#{1}\nb/")).to eq "</a\n\#{1}\nb/>"
+      expect(wrap("/a\n\#{1\n}b/")).to eq "</a\n\#{1\n}b/>"
     end
   end
 
   describe 'string literals (except heredocs)' do
     it 'wraps single and double quoted strings' do
-      wrap("'a'").should == "<'a'>"
-      wrap('"a"').should == '<"a">'
+      expect(wrap("'a'")).to eq "<'a'>"
+      expect(wrap('"a"')).to eq '<"a">'
     end
 
     it 'wraps strings with %, %Q, and %q' do
-      wrap("%'a'").should == "<%'a'>"
-      wrap("%q'a'").should == "<%q'a'>"
-      wrap("%Q'a'").should == "<%Q'a'>"
+      expect(wrap("%'a'")).to eq "<%'a'>"
+      expect(wrap("%q'a'")).to eq "<%q'a'>"
+      expect(wrap("%Q'a'")).to eq "<%Q'a'>"
     end
 
     it 'wraps strings that span mulitple lines' do
-      wrap("'a\nb'").should == "<'a\nb'>"
-      wrap(%'"a\nb"').should == %'<"a\nb">'
+      expect(wrap("'a\nb'")).to eq "<'a\nb'>"
+      expect(wrap(%'"a\nb"')).to eq %'<"a\nb">'
     end
 
     # eventually it would be nice if it wraped the interpolated portion,
     # when the end of the line was not back inside the string
     it 'wraps strings with interpolation, but not the interpolated portion' do
-      wrap('"a#{1}"').should == '<"a#{1}">'
-      wrap(%'"a\n\#{1}\nb"').should == %'<"a\n\#{1}\nb">'
-      wrap(%'"a\n\#{1\n}b"').should == %'<"a\n\#{1\n}b">'
+      expect(wrap('"a#{1}"')).to eq '<"a#{1}">'
+      expect(wrap(%'"a\n\#{1}\nb"')).to eq %'<"a\n\#{1}\nb">'
+      expect(wrap(%'"a\n\#{1\n}b"')).to eq %'<"a\n\#{1\n}b">'
     end
 
     it 'wraps %, %q, %Q' do
-      wrap('%(A)').should == '<%(A)>'
-      wrap('%.A.').should == '<%.A.>'
-      wrap('%q(A)').should == '<%q(A)>'
-      wrap('%q.A.').should == '<%q.A.>'
-      wrap('%Q(A)').should == '<%Q(A)>'
-      wrap('%Q.A.').should == '<%Q.A.>'
+      expect(wrap('%(A)')).to eq '<%(A)>'
+      expect(wrap('%.A.')).to eq '<%.A.>'
+      expect(wrap('%q(A)')).to eq '<%q(A)>'
+      expect(wrap('%q.A.')).to eq '<%q.A.>'
+      expect(wrap('%Q(A)')).to eq '<%Q(A)>'
+      expect(wrap('%Q.A.')).to eq '<%Q.A.>'
     end
 
     it 'wraps heredocs with call defined on them (edge cases on edge cases *sigh*)' do
-      wrap("<<HERE.()\na\nHERE").should == "<<<HERE.()>\na\nHERE"
+      expect(wrap("<<HERE.()\na\nHERE")).to eq "<<<HERE.()>\na\nHERE"
     end
   end
 
   describe 'heredocs' do
     it 'wraps heredocs on their first line' do
-      wrap("<<A\nA").should == "<<<A>\nA"
-      wrap("<<A\n123\nA").should == "<<<A>\n123\nA"
-      wrap("<<-A\nA").should == "<<<-A>\nA"
-      wrap("<<-A\n123\nA").should == "<<<-A>\n123\nA"
-      wrap("1\n<<A\nA").should == "<<1>\n<<A>\nA"
-      wrap("<<A + <<B\n1\nA\n2\nB").should == "<<<A + <<B>\n1\nA\n2\nB"
-      wrap("<<A\n1\nA\n<<B\n2\nB").should == "<<<<A>\n1\nA\n<<B>\n2\nB"
-      wrap("puts <<A\nA\nputs <<B\nB").should == "<puts <<A>\nA\n<puts <<B>\nB"
+      expect(wrap("<<A\nA")).to eq "<<<A>\nA"
+      expect(wrap("<<A\n123\nA")).to eq "<<<A>\n123\nA"
+      expect(wrap("<<-A\nA")).to eq "<<<-A>\nA"
+      expect(wrap("<<-A\n123\nA")).to eq "<<<-A>\n123\nA"
+      expect(wrap("1\n<<A\nA")).to eq "<<1>\n<<A>\nA"
+      expect(wrap("<<A + <<B\n1\nA\n2\nB")).to eq "<<<A + <<B>\n1\nA\n2\nB"
+      expect(wrap("<<A\n1\nA\n<<B\n2\nB")).to eq "<<<<A>\n1\nA\n<<B>\n2\nB"
+      expect(wrap("puts <<A\nA\nputs <<B\nB")).to eq "<puts <<A>\nA\n<puts <<B>\nB"
     end
 
     it "wraps methods that wrap heredocs, even whent hey don't have parentheses" do
-      wrap("a(<<HERE)\nHERE").should == "<a(<<HERE)>\nHERE"
-      wrap("a <<HERE\nHERE").should == "<a <<HERE>\nHERE"
-      wrap("a 1, <<HERE\nHERE").should == "<a 1, <<HERE>\nHERE"
-      wrap("a.b 1, 2, <<HERE1, <<-HERE2 \nHERE1\n HERE2").should ==
+      expect(wrap("a(<<HERE)\nHERE")).to eq "<a(<<HERE)>\nHERE"
+      expect(wrap("a <<HERE\nHERE")).to eq "<a <<HERE>\nHERE"
+      expect(wrap("a 1, <<HERE\nHERE")).to eq "<a 1, <<HERE>\nHERE"
+      expect(wrap("a.b 1, 2, <<HERE1, <<-HERE2 \nHERE1\n HERE2")).to eq\
           "<a.b 1, 2, <<HERE1, <<-HERE2> \nHERE1\n HERE2"
-      wrap("a.b 1,\n2,\n<<HERE\nHERE").should == "<a.b <1>,\n<2>,\n<<HERE>\nHERE"
+      expect(wrap("a.b 1,\n2,\n<<HERE\nHERE")).to eq "<a.b <1>,\n<2>,\n<<HERE>\nHERE"
     end
 
     it "wraps assignments whose value is a heredoc" do
-      wrap("a=<<A\nA").should == "<a=<<A>\nA"
-      wrap("a,b=<<A,<<B\nA\nB").should == "<a,b=<<A,<<B>\nA\nB"
-      wrap("a,b=1,<<B\nB").should == "<a,b=1,<<B>\nB"
-      wrap("a,b=<<A,1\nA").should == "<a,b=<<A,1>\nA"
+      expect(wrap("a=<<A\nA")).to eq "<a=<<A>\nA"
+      expect(wrap("a,b=<<A,<<B\nA\nB")).to eq "<a,b=<<A,<<B>\nA\nB"
+      expect(wrap("a,b=1,<<B\nB")).to eq "<a,b=1,<<B>\nB"
+      expect(wrap("a,b=<<A,1\nA")).to eq "<a,b=<<A,1>\nA"
     end
 
     it 'wraps methods tacked onto the end of heredocs' do
-      wrap("<<A.size\nA").should == "<<<A.size>\nA"
-      wrap("<<A.size 1\nA").should == "<<<A.size 1>\nA"
-      wrap("<<A.size(1)\nA").should == "<<<A.size(1)>\nA"
-      wrap("<<A.whatever <<B\nA\nB").should == "<<<A.whatever <<B>\nA\nB"
-      wrap("<<A.whatever(<<B)\nA\nB").should == "<<<A.whatever(<<B)>\nA\nB"
-      wrap("<<A.size()\nA").should == "<<<A.size()>\nA"
+      expect(wrap("<<A.size\nA")).to eq "<<<A.size>\nA"
+      expect(wrap("<<A.size 1\nA")).to eq "<<<A.size 1>\nA"
+      expect(wrap("<<A.size(1)\nA")).to eq "<<<A.size(1)>\nA"
+      expect(wrap("<<A.whatever <<B\nA\nB")).to eq "<<<A.whatever <<B>\nA\nB"
+      expect(wrap("<<A.whatever(<<B)\nA\nB")).to eq "<<<A.whatever(<<B)>\nA\nB"
+      expect(wrap("<<A.size()\nA")).to eq "<<<A.size()>\nA"
     end
   end
 
   # raises can be safely ignored, they're just method invocations
   describe 'begin/rescue/else/ensure/end blocks' do
     it 'wraps begin/rescue/else/ensure/end blocks' do
-      wrap("begin\nrescue\nelse\nensure\nend").should == "<begin\nrescue\nelse\nensure\nend>"
-      wrap("begin\nrescue e\ne\nend").should == "<begin\nrescue e\n<e>\nend>"
-      wrap("begin\nrescue Exception\n$!\nend").should == "<begin\nrescue Exception\n<$!>\nend>"
+      expect(wrap("begin\nrescue\nelse\nensure\nend")).to eq "<begin\nrescue\nelse\nensure\nend>"
+      expect(wrap("begin\nrescue e\ne\nend")).to eq "<begin\nrescue e\n<e>\nend>"
+      expect(wrap("begin\nrescue Exception\n$!\nend")).to eq "<begin\nrescue Exception\n<$!>\nend>"
     end
     it 'wraps inline rescues' do
-      pending "can't figure out how to identify these as different from begin/rescue/end" do
-        wrap("1 rescue nil").should == "<1 rescue nil>"
-      end
+      pending "can't figure out how to identify these as different from begin/rescue/end"
+      expect(wrap("1 rescue nil")).to eq "<1 rescue nil>"
     end
     it 'wraps the bodies' do
-      wrap("begin\n1\nrescue\n2\nelse\n3\nensure\n4\nend").should ==
+      expect(wrap("begin\n1\nrescue\n2\nelse\n3\nensure\n4\nend")).to eq\
         "<begin\n<1>\nrescue\n<2>\nelse\n<3>\nensure\n<4>\nend>"
     end
     it 'wraps bodies with various pieces missing' do
-      wrap("begin\n1\nrescue\n2\nelse\n3\nensure\n4\nend").should == "<begin\n<1>\nrescue\n<2>\nelse\n<3>\nensure\n<4>\nend>"
-      wrap("begin\n1\nrescue\n2\nelse\n3\nend").should == "<begin\n<1>\nrescue\n<2>\nelse\n<3>\nend>"
-      wrap("begin\n1\nrescue\n2\nend").should == "<begin\n<1>\nrescue\n<2>\nend>"
-      wrap("begin\n1\nend").should == "<begin\n<1>\nend>"
-      wrap("begin\nend").should == "<begin\nend>"
-      wrap("begin\n1\nensure\n2\nend").should == "<begin\n<1>\nensure\n<2>\nend>"
+      expect(wrap("begin\n1\nrescue\n2\nelse\n3\nensure\n4\nend")).to eq "<begin\n<1>\nrescue\n<2>\nelse\n<3>\nensure\n<4>\nend>"
+      expect(wrap("begin\n1\nrescue\n2\nelse\n3\nend")).to eq "<begin\n<1>\nrescue\n<2>\nelse\n<3>\nend>"
+      expect(wrap("begin\n1\nrescue\n2\nend")).to eq "<begin\n<1>\nrescue\n<2>\nend>"
+      expect(wrap("begin\n1\nend")).to eq "<begin\n<1>\nend>"
+      expect(wrap("begin\nend")).to eq "<begin\nend>"
+      expect(wrap("begin\n1\nensure\n2\nend")).to eq "<begin\n<1>\nensure\n<2>\nend>"
     end
     it 'does not wrap arguments to rescue' do
-      wrap("begin\nrescue\nrescue => a\nrescue SyntaxError\nrescue Exception => a\nelse\nensure\nend").should ==
+      expect(wrap("begin\nrescue\nrescue => a\nrescue SyntaxError\nrescue Exception => a\nelse\nensure\nend")).to eq\
             "<begin\nrescue\nrescue => a\nrescue SyntaxError\nrescue Exception => a\nelse\nensure\nend>"
     end
     it 'does not wrap retry' do
       # in this case, it could wrap the retry
       # but I don't know how to tell the difference between this and
       # "loop { begin; retry; end }" so w/e
-      wrap("begin\nrescue\nretry\nend").should == "<begin\nrescue\nretry\nend>"
+      expect(wrap("begin\nrescue\nretry\nend")).to eq "<begin\nrescue\nretry\nend>"
     end
   end
 
@@ -686,19 +752,19 @@ describe SeeingIsBelieving::WrapExpressions do
   # ignoring public/private/protected for now, b/c they're just methods, not keywords
   describe 'class definitions' do
     it 'does not wrap the class definition, does wrap the body' do
-      wrap("class A\n1\nend").should == "class A\n<1>\nend"
+      expect(wrap("class A\n1\nend")).to eq "class A\n<1>\nend"
     end
 
     it 'does not wrap the superclass definition' do
-      wrap("class A < B\nend").should == "class A < B\nend"
+      expect(wrap("class A < B\nend")).to eq "class A < B\nend"
     end
 
     it 'wraps the rescue body' do
-      wrap("class A < B\n1\nrescue\n2\nend").should == "class A < B\n<1>\nrescue\n<2>\nend"
+      expect(wrap("class A < B\n1\nrescue\n2\nend")).to eq "class A < B\n<1>\nrescue\n<2>\nend"
     end
 
     it 'does not wrap the singleton class' do
-      wrap("class << self\n end").should == "class << self\n end"
+      expect(wrap("class << self\n end")).to eq "class << self\n end"
     end
   end
 
@@ -707,65 +773,63 @@ describe SeeingIsBelieving::WrapExpressions do
   # ignoring public/private/protected for now, b/c they're just methods, not keywords
   describe 'module definitions' do
     it 'does not wrap the definition, does wrap the body' do
-      wrap("module A\n1\nend").should == "module A\n<1>\nend"
+      expect(wrap("module A\n1\nend")).to eq "module A\n<1>\nend"
     end
     it 'wraps the rescue portion' do
-      wrap("module A\n1\nrescue\n2\nend").should == "module A\n<1>\nrescue\n<2>\nend"
+      expect(wrap("module A\n1\nrescue\n2\nend")).to eq "module A\n<1>\nrescue\n<2>\nend"
     end
   end
 
   describe 'method definitions' do
     it 'does not wrap the definition or arguments' do
-      wrap("def a(b,c=1,*d,&e)\nend").should == "def a(b,c=1,*d,&e)\nend"
+      expect(wrap("def a(b,c=1,*d,&e)\nend")).to eq "def a(b,c=1,*d,&e)\nend"
     end
 
     it 'wraps the body' do
-      wrap("def a\n1\nend").should == "def a\n<1>\nend"
-      wrap("def a()\n1\nend").should == "def a()\n<1>\nend"
+      expect(wrap("def a\n1\nend")).to eq "def a\n<1>\nend"
+      expect(wrap("def a()\n1\nend")).to eq "def a()\n<1>\nend"
     end
 
     it 'does not try to wrap singleton method definitions' do
-      wrap("def a.b\n1\nend").should == "def a.b\n<1>\nend"
-      wrap("def a.b()\n1\nend").should == "def a.b()\n<1>\nend"
+      expect(wrap("def a.b\n1\nend")).to eq "def a.b\n<1>\nend"
+      expect(wrap("def a.b()\n1\nend")).to eq "def a.b()\n<1>\nend"
     end
 
     it 'wraps calls to yield' do
-      wrap("def a\nyield\nend").should == "def a\n<yield>\nend"
+      expect(wrap("def a\nyield\nend")).to eq "def a\n<yield>\nend"
     end
 
     it 'wraps calls to super' do
-      wrap("def a\nsuper\nend").should == "def a\n<super>\nend"
-      wrap("def a\nsuper 1\nend").should == "def a\n<super 1>\nend"
+      expect(wrap("def a\nsuper\nend")).to eq "def a\n<super>\nend"
+      expect(wrap("def a\nsuper 1\nend")).to eq "def a\n<super 1>\nend"
     end
 
     it 'wraps the bodies of returns' do
-      wrap("def a\nreturn 1\nend").should == "def a\nreturn <1>\nend"
+      expect(wrap("def a\nreturn 1\nend")).to eq "def a\nreturn <1>\nend"
     end
 
     it 'wraps the rescue and ensure portion' do
-      wrap("def a\n1\nrescue\n2\nend").should == "def a\n<1>\nrescue\n<2>\nend"
-      wrap("def a\n1\nrescue\n2\nensure\n3\nend").should == "def a\n<1>\nrescue\n<2>\nensure\n<3>\nend"
-      wrap("def a\n1\nensure\n2\nend").should == "def a\n<1>\nensure\n<2>\nend"
+      expect(wrap("def a\n1\nrescue\n2\nend")).to eq "def a\n<1>\nrescue\n<2>\nend"
+      expect(wrap("def a\n1\nrescue\n2\nensure\n3\nend")).to eq "def a\n<1>\nrescue\n<2>\nensure\n<3>\nend"
+      expect(wrap("def a\n1\nensure\n2\nend")).to eq "def a\n<1>\nensure\n<2>\nend"
     end
   end
 
   describe 'lambdas' do
     it 'wraps the lambda' do
-      wrap("lambda { }").should == "<lambda { }>"
-      wrap("-> { }").should == "<-> { }>"
-      wrap("-> a, b { }").should == "<-> a, b { }>"
-      wrap("-> {\n1\n}").should == "<-> {\n<1>\n}>"
-      wrap("-> * { }").should == "<-> * { }>"
+      expect(wrap("lambda { }")).to eq "<lambda { }>"
+      expect(wrap("-> { }")).to eq "<-> { }>"
+      expect(wrap("-> a, b { }")).to eq "<-> a, b { }>"
+      expect(wrap("-> {\n1\n}")).to eq "<-> {\n<1>\n}>"
+      expect(wrap("-> * { }")).to eq "<-> * { }>"
     end
 
     it 'wraps the full invocation' do
-      wrap("lambda { }.()").should == "<lambda { }.()>"
-      wrap("-> { }.()").should == "<-> { }.()>"
-      wrap("-> a, b {\n1\n}.(1,\n2)").should == "<-> a, b {\n<1>\n}.(<1>,\n2)>"
-      wrap("-> a, b { }.call(1, 2)").should == "<-> a, b { }.call(1, 2)>"
-      pending "Parser doesn't parse this https://github.com/whitequark/parser/issues/103" do
-        wrap("-> * { }()").should == "<-> * { }.()>"
-      end
+      expect(wrap("lambda { }.()")).to eq "<lambda { }.()>"
+      expect(wrap("-> { }.()")).to eq "<-> { }.()>"
+      expect(wrap("-> a, b {\n1\n}.(1,\n2)")).to eq "<-> a, b {\n<1>\n}.(<1>,\n2)>"
+      expect(wrap("-> a, b { }.call(1, 2)")).to eq "<-> a, b { }.call(1, 2)>"
+      expect(wrap("-> * { }.()")).to eq "<-> * { }.()>"
     end
   end
 
@@ -790,12 +854,11 @@ describe SeeingIsBelieving::WrapExpressions do
     # which we could do with some meta, just replacing it with the literal when we parse it
     # but still, moving this out of here will be really annoying, and no one is going to use it, so fuck it
     it 'does not record them', not_implemented: true do
-      pending 'not implemented, and probably never will be' do
-        wrap("BEGIN {}").should == "BEGIN {}"
-        wrap("END {}").should == "END {}"
-        wrap("BEGIN {\n123\n}").should == "BEGIN {\n<123>\n}"
-        wrap("END {\n123\n}").should == "END {\n<123>\n}"
-      end
+      pending 'not implemented, and probably never will be'
+      expect(wrap("BEGIN {}")).to eq "BEGIN {}"
+      expect(wrap("END {}")).to eq "END {}"
+      expect(wrap("BEGIN {\n123\n}")).to eq "BEGIN {\n<123>\n}"
+      expect(wrap("END {\n123\n}")).to eq "END {\n<123>\n}"
     end
   end
 end