seeing_is_believing 1.0.1 → 2.0.0.beta1

data/spec/seeing_is_believing_spec.rb

@@ -14,8 +14,8 @@ 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
-    input  = "1+1\n'2'+'2'"
-    invoke(input)[1].should == ["2"]
+    input  = "10+10\n'2'+'2'"
+    invoke(input)[1].should == ["20"]
     invoke(input)[2].should == ['"22"']
   end
 
@@ -38,78 +38,25 @@ describe SeeingIsBelieving do
   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']]
+    values_for("(1..2).each do |i|\ni\nend").should == [['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
-    vs = values_for('if true &&
-                          if true &&
-                                    true
-                            1
-                          end
-                  2
-                end').should == [[], [], ['true'], ['1'], ['1'], ['2'], ['2']]
-
-    values_for("[3].map do |n|\n n*2\n end").should == [[], ['6'], ['[6]']]
-
-    values_for("[1].map do |n1|
-                  [2].map do |n2|
-                    n1 + n2
-                  end
-                end").should == [[], [], ['3'], ['[3]'], ['[[3]]']]
-
-    values_for("[1].map do |n1|
-                  [2].map do |n2| n1 + n2
-                  end
-                end").should == [[], [], ['[3]'], ['[[3]]']]
-
-    values_for("[1].map do |n1|
-                  [2].map do |n2|
-                    n1 + n2 end
-                end").should == [[], [], ['[3]'], ['[[3]]']]
-
-    values_for("[1].map do |n1|
-                  [2].map do |n2|
-                    n1 + n2 end end").should == [[], [], ['[[3]]']]
-
-    values_for("[1].map do |n1|
-                  [2].map do |n2| n1 + n2 end end").should == [[], ['[[3]]']]
-
-    values_for("[1].map do |n1| [2].map do |n2| n1 + n2 end end").should == [['[[3]]']]
-
-    values_for("[1].map do |n1|
-                  [2].map do |n2|
-                    n1 + n2
-                end end").should == [[], [], ['3'], ['[[3]]']]
-
-    values_for("[1].map do |n1| [2].map do |n2|
-                  n1 + n2
-                end end").should == [[], ['3'], ['[[3]]']]
-
-    values_for("[1].map do |n1| [2].map do |n2|
-                  n1 + n2 end end").should == [[], ['[[3]]']]
-
-    values_for("[1].map do |n1| [2].map do |n2|
-                  n1 + n2 end
-                end").should == [[], [], ['[[3]]']]
-
-    values_for("1 +
-                    2").should == [[], ['3']]
-
+    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"']]
+  end
 
-    # fails b/c parens should go around line 1, not around entire expression -.^
-    # values_for("<<HEREDOC\n1\nHEREDOC").should == [[], [], ['"\n1\n"']]
-    # values_for("<<-HEREDOC\n1\nHEREDOC").should == [[], [], ['"\n1\n"']]
+  it 'records the targets of chained methods' do
+    values_for("[*1..5]\n.map { |n| n * 2 }\n.take(2)\n.size").should ==
+      [["[1, 2, 3, 4, 5]"], ["[2, 4, 6, 8, 10]"], ["[2, 4]"], ["2"]]
   end
 
-  it "does not record expressions that are here docs (only really b/c it's not smart enough)" do
-    values_for("<<A\n1\nA").should be_all &:empty?
-    values_for(" <<A\n1\nA").should be_all &:empty?
-    values_for("<<-A\n1\n A").should be_all &:empty?
-    values_for(" <<-A\n1\n A").should be_all &:empty?
-    values_for("s=<<-A\n1\n A").should be_all &:empty?
-    values_for("def meth\n<<-A\n1\nA\nend").should == [[], [], [], [], ['nil']]
+  it "records heredocs" do
+    values_for("<<A\n1\nA").should == [[%'"1\\n"']]
+    values_for("<<-A\n1\nA").should == [[%'"1\\n"']]
   end
 
   it 'does not insert code into the middle of heredocs' do
@@ -153,7 +100,6 @@ describe SeeingIsBelieving do
     result[2].exception.should == result.exception
 
     result[3].should == []
-    result.to_a.size.should == 3
   end
 
   it 'records the backtrace on the errors' do
@@ -171,24 +117,29 @@ describe SeeingIsBelieving do
                 meth
 
                 # comment
-                __LINE__').should == [['1'], ['2'], [], [], ['5'], ['nil'], ['5'], [], [], ['10']]
+                __LINE__').should == [['1'], ['2'], [], [], ['5'], [], ['5'], [], [], ['10']]
   end
 
-  it 'does not try to record a return statement when that will break it' do
-    values_for("def meth \n return 1          \n end \n meth").should == [[], [], ['nil'], ['1']]
-    values_for("def meth \n return 1 if true  \n end \n meth").should == [[], [], ['nil'], ['1']]
-    values_for("def meth \n return 1 if false \n end \n meth").should == [[], [], ['nil'], ['nil']]
-    values_for("-> {  \n return 1          \n }.call"        ).should == [[], [], ['1']]
-    # this doesn't work because the return detecting code is a very conservative regexp
-    # values_for("-> { return 1 }.call"        ).should == [['1']]
+  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 "we'd like this to record 1 and nil, but currently we dont' differentiate between inline and multiline if statements" do
+      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
   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 == [[], [], ['2'], ['1..2']]
+    # tbh, I don't even really know what I want in this case. Maybe record nothing since there is no arg to next?
+    pending 'broken because of misordering in the rewriter' do
+      values_for("(1..2).each do |i|\nnext if i == 1\ni\nend").should == [['1..2'], [], ['true', 'false'], ['1..2']]
+    end
   end
 
   it 'does not try to record the keyword redo' do
-    values_for(<<-DOC).should == [[], ['0'], [], ['1', '2', '3', '4'], [], ['0...3'], ['nil'], ['0...3']]
+    values_for(<<-DOC).should == [[], ['0'], ['0...3'], ['1', '2', '3', '4'], ['false', 'true', 'false', 'false'], ['0...3'], [], ['0...3']]
       def meth
         n = 0
         for i in 0...3
@@ -201,21 +152,25 @@ describe SeeingIsBelieving do
   end
 
   it 'does not try to record the keyword retry' do
-    values_for(<<-DOC).should == [[], [], [], ['nil']]
-      def meth
-      rescue
-        retry
-      end
-    DOC
+    pending 'uhhh, what do I want here?' do
+      values_for(<<-DOC).should == [[], [], [], ['nil']]
+        def meth
+        rescue
+          retry
+        end
+      DOC
+    end
   end
 
   it 'does not try to record the keyword retry' do
-    values_for(<<-DOC).should == [[], ['0'], [], ['nil']]
-      (0..2).each do |n|
-        n
-        break
-      end
-    DOC
+    pending 'uhhh, what do I want here?' do
+      values_for(<<-DOC).should == [[], ['0'], [], ['nil']]
+        (0..2).each do |n|
+          n
+          break
+        end
+      DOC
+    end
   end
 
   it 'does not affect its environment' do
@@ -260,7 +215,7 @@ describe SeeingIsBelieving do
   end
 
   it 'does not capture output from __END__ onward' do
-    values_for("1+1\nDATA.read\n__END__\n....").should == [['2'], ['"...."']]
+    values_for("1+1\nDATA.read\n__END__\n....").should == [['2'], ['"....\n"']] # <-- should this actually write a newline on the end?
   end
 
   it 'raises a SyntaxError when the whole program is invalid' do
@@ -280,8 +235,9 @@ describe SeeingIsBelieving do
   end
 
   it 'can deal with methods that are invoked entirely on the next line' do
-    values_for("a = 1\n.even?\na").should == [[], ['false'], ['false']]
-    values_for("1\n.even?\n__END__").should == [[], ['false']]
+    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']]
   end
 
   it 'does not record leading comments' do
@@ -309,7 +265,7 @@ describe SeeingIsBelieving do
 
   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'], []]
+                # encoding: wtf').should == [['2']]
   end
 
   it "doesn't remove multiple leading comments" do
@@ -321,23 +277,23 @@ describe SeeingIsBelieving do
                "2").should == [[], ['1'], ['2']]
   end
 
-  it 'can record the middle of a chain of calls', not_implemented: true  do
+  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]']]
-    # values_for("1 +\n2").should == [['1'], ['3']]
-    # values_for("1\\\n+ 2").should == [['1'], ['3']]
+    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
 
   context 'when given a debugger' do
@@ -347,22 +303,18 @@ describe SeeingIsBelieving do
       invoke "1", debugger: debugger
     end
 
-    it 'prints the program without comments' do
-      call
-      debugger.to_s.should include "SOURCE WITHOUT COMMENTS:"
-      debugger.to_s.should include "\n1\n"
-    end
-
     it 'prints the pre-evaluated program' do
       call
       debugger.to_s.should include "TRANSLATED PROGRAM:"
       debugger.to_s.should include "\nbegin;" # there is more, but we're just interested in showing that it wound up in the stream
     end
 
-    it 'has the ExpressionList print its debug options into the output' do
+    it 'prints the result', t:true do
       call
-      debugger.to_s.should include "EXPRESSION EVALUATION:"
+      debugger.to_s.should include "RESULT:"
+      debugger.to_s.should include '1=>#<SIB:Line["1"] no exception>'
     end
+    # should ProgramRewriter have some debug options?
   end
 
 end

data/spec/syntax_analyzer_spec.rb

@@ -1,52 +1,6 @@
 require 'seeing_is_believing'
 
 describe SeeingIsBelieving::SyntaxAnalyzer do
-  it 'knows if syntax is valid' do
-    is_valid = lambda { |code| described_class.valid_ruby? code }
-    is_valid['1+2'].should be_true
-    is_valid['+'].should be_false
-    is_valid["=begin\n1\n=end"].should be_true
-
-    # due to what are possibly bugs in Ripper
-    # these don't raise any errors, so have to check them explicitly
-    is_valid["'"].should be_false
-    is_valid["/"].should be_false
-    is_valid["=begin"].should be_false
-    is_valid[" =begin"].should be_false
-    is_valid[" = begin"].should be_false
-    is_valid["=begin\n1"].should be_false
-    is_valid["=begin\n1\n=end\n=begin"].should be_false
-    is_valid["=begin\n1\n=end\n=end"].should be_false
-  end
-
-  it 'knows if the expression is a heredoc' do
-    is_here_doc = lambda { |code| described_class.here_doc? code }
-    is_here_doc["<<A\nA"].should be_true
-    is_here_doc["a=<<A\nabc\nA"].should be_true
-    is_here_doc["meth(<<A)\nabc\nA"].should be_true
-    is_here_doc["meth(<<A)\nabc\nA"].should be_true
-    is_here_doc["meth(<<-A)\n abc\n A"].should be_true
-    is_here_doc["meth(<<-\"a b\")\n abc\n a b"].should be_true
-    is_here_doc["meth(<<-\"a b\", <<something)\n 1\n a b\n2\nsomething"].should be_true
-
-    is_here_doc["a=<<A\nabc\nA\na"].should be_false
-    is_here_doc["def meth\nwhateva(<<A)\nabc\nA\nend"].should be_false
-    is_here_doc["a << b\nb"].should be_false
-    is_here_doc["a<<b\nb"].should be_false
-  end
-
-  it 'knows if the expression is an unfinished heredoc' do
-    is_unfinished_heredoc = lambda { |code| described_class.unfinished_here_doc? code }
-    is_unfinished_heredoc["<<A"].should be_true
-    is_unfinished_heredoc["puts <<A, <<B\na\nA"].should be_true
-    is_unfinished_heredoc["<<-A\n"].should be_true
-
-    is_unfinished_heredoc["puts <<A\na\nA"].should be_false
-    is_unfinished_heredoc["puts <<-A\na\nA"].should be_false
-    is_unfinished_heredoc["puts <<-A\na\n A"].should be_false
-    is_unfinished_heredoc["puts <<A, <<B\na\nA\nB"].should be_false
-  end
-
   it 'knows if the last line is a comment' do
     is_comment = lambda { |code| described_class.ends_in_comment? code }
 
@@ -62,6 +16,9 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     is_comment["a # whatev \n b"].should be_false
     is_comment[""].should be_false
     is_comment["=begin\n=end\n\n =end"].should be_false
+    pending "Fix comments to not be shit" do
+      is_comment[%'"\n\#{1}"'].should be_false
+    end
   end
 
   it 'knows if it contains an unclosed comment' do
@@ -92,278 +49,8 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     described_class.line_is_comment?('abc').should be_false
   end
 
-  # probably don't really need this many tests, but I'm unfamiliar with how thorough Ripper is
-  # and already found areas where it doesn't behave correctly
-  it 'knows if the code contains an unclosed string' do
-    is_unclosed_string = lambda { |code| described_class.unclosed_string? code }
-    [%(a),
-     %("a"),
-     %("a \n"),
-     %("a \n a"),
-     %(a \n" a"),
-     %(a \n' a'),
-     %('a' "b"),
-     %('a"b'),
-     %("a'b"),
-     %("a\\""),
-     %(%()),
-     %(%<>),
-     %(%[]),
-     %(%{}),
-     %(%Q()),
-     %(%q()),
-     %("\#{""}"),
-     %("\#{''}"),
-     %("\#{%(\#{%[\#{%[]}]})}"),
-     %(%{}),
-     %(%<>),
-     %(%..),
-    ].each do |string|
-      is_unclosed_string[string].should be_false, "Expected #{string.inspect} to be closed"
-    end
-
-    [%(a "),
-     %(a '),
-     %("a \n),
-     %(a \n 'a\n),
-     %("a"\n"b),
-     %("a" "b),
-     %("a" "b'),
-     %("a\\"),
-     %('a\\'),
-     %(%\(),
-     %(%<),
-     %(%[),
-     %(%{),
-     %(%Q[),
-     %(%q[),
-     %(%Q(\#{)),
-     %("\#{),
-     %("\#{'}"),
-     %("\#{"}"),
-     %("\#{%(\#{%[\#{%[}]})}"),
-    ].each do |string|
-      is_unclosed_string[string].should be_true, "Expected #{string.inspect} to be unclosed"
-    end
-  end
-
-  it 'knows if the code contains an unclosed regexp' do
-    is_unclosed_regexp = lambda { |code| described_class.unclosed_regexp? code }
-    [%(a),
-     %(/a/),
-     %(/a \n/),
-     %(/a \n a/),
-     %(a \n/ a/),
-     %(/a\\//),
-     %(/\#{//}/),
-     %(%r()),
-     %(%r{}),
-     %(%r<>),
-     %(%r..),
-     %(/\na\nb\n/x),
-     %(r..i),
-     %(/\na\nb\n/xmi),
-    ].each do |code|
-      is_unclosed_regexp[code].should be_false, "Expected #{code.inspect} to be closed"
-    end
-
-    [%(a + /),
-     %(/a \n),
-     %(a \n /a\n),
-     %(/a/\n/b),
-     %(/a\\/),
-     %(%r\(),
-     %(%r<),
-     %(%r[),
-     %(%r{),
-     %(%r(\#{)),
-     %(%r[\#{),
-     %("\#{%r[}"),
-    ].each do |code|
-      is_unclosed_regexp[code].should be_true, "Expected #{code.inspect} to be unclosed"
-    end
-  end
-
-  shared_examples_for 'single line void_value_expression?' do |keyword, options={}|
-    specify "`#{keyword}` returns true when the expression ends in #{keyword} without an argument" do
-      described_class.void_value_expression?("#{keyword}").should be_true
-      described_class.void_value_expression?("#{keyword} if true").should be_true
-      described_class.void_value_expression?("o.#{keyword}").should be_false
-      described_class.void_value_expression?(":#{keyword}").should be_false
-      described_class.void_value_expression?(":'#{keyword}'").should be_false
-      described_class.void_value_expression?("'#{keyword}'").should be_false
-      described_class.void_value_expression?("def a\n#{keyword}\nend").should be_false
-      described_class.void_value_expression?("-> {\n#{keyword}\n}").should be_false
-      described_class.void_value_expression?("Proc.new {\n#{keyword}\n}").should be_false
-      described_class.void_value_expression?("#{keyword}_something").should be_false
-      described_class.void_value_expression?("'#{keyword}\n#{keyword}\n#{keyword}'").should be_false
-
-      unless options[:no_args]
-        described_class.void_value_expression?("#{keyword}(1)").should be_true
-        described_class.void_value_expression?("#{keyword} 1").should be_true
-        described_class.void_value_expression?("#{keyword} 1\n").should be_true
-        described_class.void_value_expression?("#{keyword} 1 if true").should be_true
-        described_class.void_value_expression?("#{keyword} 1 if false").should be_true
-        described_class.void_value_expression?("def a\n#{keyword} 1\nend").should be_false
-        described_class.void_value_expression?("-> {\n#{keyword} 1\n}").should be_false
-        described_class.void_value_expression?("Proc.new {\n#{keyword} 1\n}").should be_false
-        described_class.void_value_expression?("#{keyword} \\\n1").should be_true
-      end
-    end
-
-    it "knows when an if statement ends in `#{keyword}`" do
-      # if
-      described_class.void_value_expression?("if true\n#{keyword}\nend").should be_true
-      described_class.void_value_expression?("if true\n  #{keyword}\nend").should be_true
-      described_class.void_value_expression?("if true\n 1+1\n  #{keyword}\nend").should be_true
-      described_class.void_value_expression?("if true\n #{keyword}\n 1+1\n end").should be_false
-      described_class.void_value_expression?("123 && if true\n  #{keyword}\nend").should be_false
-      described_class.void_value_expression?("def m\n if true\n  #{keyword}\nend\n end").should be_false
-      described_class.void_value_expression?("if true; #{keyword}; end").should be_true
-      described_class.void_value_expression?("if true; 1; end").should be_false
-
-      # if .. elsif
-      described_class.void_value_expression?("if true\n #{keyword}\n elsif true\n 1\n end").should be_true
-      described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n end").should be_true
-      described_class.void_value_expression?("if true\n #{keyword}\n 2\n elsif true\n 1\n end").should be_false
-      described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n 2\n end").should be_false
-
-      # if .. else
-      described_class.void_value_expression?("if true\n #{keyword}\n else 1\n end").should be_true
-      described_class.void_value_expression?("if true\n 1\n else\n #{keyword}\n end").should be_true
-      described_class.void_value_expression?("if true\n #{keyword}\n 2\n else 1\n end").should be_false
-      described_class.void_value_expression?("if true\n 1\n else\n #{keyword}\n 2\n end").should be_false
-
-      # if .. elsif .. else .. end
-      described_class.void_value_expression?("if true\n #{keyword}\nelsif true\n 1 else 1\n end").should be_true
-      described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n else\n 1\n end").should be_true
-      described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n elsif true\n #{keyword}\n else\n 1\n end").should be_true
-      described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n else\n #{keyword}\n end").should be_true
-      described_class.void_value_expression?("if true\n #{keyword}\n 2\nelsif true\n 1 else 1\n end").should be_false
-      described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n 2\n else\n 1\n end").should be_false
-      described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n elsif true\n #{keyword}\n 2\n else\n 1\n end").should be_false
-      described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n else\n #{keyword}\n 2\n end").should be_false
-
-      unless options[:no_args]
-        # if
-        described_class.void_value_expression?("if true\n#{keyword} 1\nend").should be_true
-        described_class.void_value_expression?("if true\n  #{keyword} 1\nend").should be_true
-        described_class.void_value_expression?("if true\n 1+1\n  #{keyword} 1\nend").should be_true
-        described_class.void_value_expression?("if true\n #{keyword} 1\n 1+1\n end").should be_false
-        described_class.void_value_expression?("123 && if true\n  #{keyword} 1\nend").should be_false
-        described_class.void_value_expression?("def m\n if true\n  #{keyword} 1\nend\n end").should be_false
-        described_class.void_value_expression?("if true; #{keyword} 1; end").should be_true
-        described_class.void_value_expression?("if true; 1; end").should be_false
-
-        # if .. elsif
-        described_class.void_value_expression?("if true\n #{keyword} 1\n elsif true\n 1\n end").should be_true
-        described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n end").should be_true
-        described_class.void_value_expression?("if true\n #{keyword} 1\n 2\n elsif true\n 1\n end").should be_false
-        described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n 2\n end").should be_false
-
-        # if .. else
-        described_class.void_value_expression?("if true\n #{keyword} 1\n else 1\n end").should be_true
-        described_class.void_value_expression?("if true\n 1\n else\n #{keyword}\n end").should be_true
-        described_class.void_value_expression?("if true\n #{keyword} 1\n 2\n else 1\n end").should be_false
-        described_class.void_value_expression?("if true\n 1\n else\n #{keyword}\n 2\n end").should be_false
-
-        # if .. elsif .. else .. end
-        described_class.void_value_expression?("if true\n #{keyword} 1\nelsif true\n 1 else 1\n end").should be_true
-        described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n else\n 1\n end").should be_true
-        described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n elsif true\n #{keyword}\n else\n 1\n end").should be_true
-        described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n else\n #{keyword}\n end").should be_true
-        described_class.void_value_expression?("if true\n #{keyword} 1\n 2\nelsif true\n 1 else 1\n end").should be_false
-        described_class.void_value_expression?("if true\n 1\n elsif true\n #{keyword}\n 2\n else\n 1\n end").should be_false
-        described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n elsif true\n #{keyword}\n 2\n else\n 1\n end").should be_false
-        described_class.void_value_expression?("if true\n 1\n elsif true\n 1\n else\n #{keyword}\n 2\n end").should be_false
-      end
-    end
-
-    it "knows when a begin statement ends in `#{keyword}`" do
-      described_class.void_value_expression?("begin\n #{keyword}\n end").should be_true
-      described_class.void_value_expression?("begin\n 1\n #{keyword}\n end").should be_true
-      described_class.void_value_expression?("begin\n #{keyword}\n 1\n end").should be_false
-      described_class.void_value_expression?("begin\n 1\n #{keyword}\n 1\n end").should be_false
-
-      unless options[:no_args]
-        described_class.void_value_expression?("begin\n #{keyword} '123' \n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n #{keyword} 456\n end").should be_true
-        described_class.void_value_expression?("begin\n #{keyword} :'789'\n 1\n end").should be_false
-        described_class.void_value_expression?("begin\n 1\n #{keyword} /101112/\n 1\n end").should be_false
-      end
-
-      # I don't know that the rest of these hold across all versions of Ruby since they make no fucking sense
-      # so even though some of them can technically be non-vve,
-      # I'm still going to call any one of them a vve
-      #
-      # e.g. (tested on 2.0)
-      #   this is allowed
-      #     -> { a = begin;  return
-      #              rescue; return
-      #              ensure; return
-      #              end }
-      #   this is not
-      #     -> { a = begin; return
-      #              end }
-
-      # with rescue...
-      described_class.void_value_expression?("begin\n #{keyword}\n rescue\n #{keyword} end").should be_true
-      described_class.void_value_expression?("begin\n 1\n #{keyword}\n rescue RuntimeError => e\n end").should be_true
-      described_class.void_value_expression?("begin\n 1\n #{keyword}\n rescue RuntimeError\n end").should be_true
-      described_class.void_value_expression?("begin\n 1\n #{keyword}\n rescue\n end").should be_true
-      described_class.void_value_expression?("begin\n 1\n rescue\n end").should be_false
-      described_class.void_value_expression?("begin\n 1\n rescue\n #{keyword}\n end").should be_true
-      described_class.void_value_expression?("begin\n 1\n rescue\n #{keyword}\n 1\n end").should be_false
-
-      unless options[:no_args]
-        described_class.void_value_expression?("begin\n #{keyword}\n rescue\n #{keyword} 1 end").should be_true
-        described_class.void_value_expression?("begin\n 1\n #{keyword} 1\n rescue RuntimeError => e\n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n #{keyword} 1\n rescue RuntimeError\n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n #{keyword} :abc\n rescue\n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n rescue\n #{keyword} 'abc'\n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n rescue\n #{keyword} :abc\n 1\n end").should be_false
-      end
-
-      # with ensure
-      described_class.void_value_expression?("begin\n #{keyword}\n ensure\n #{keyword} end").should be_true
-      described_class.void_value_expression?("begin\n 1\n #{keyword}\n ensure\n end").should be_true
-      described_class.void_value_expression?("begin\n 1\n ensure\n end").should be_false
-      described_class.void_value_expression?("begin\n 1\n ensure\n #{keyword}\n end").should be_true
-      described_class.void_value_expression?("begin\n 1\n ensure\n #{keyword}\n 1\n end").should be_false
-
-      unless options[:no_args]
-        described_class.void_value_expression?("begin\n #{keyword}\n ensure\n #{keyword} 1 end").should be_true
-        described_class.void_value_expression?("begin\n 1\n #{keyword} 1\n ensure\n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n #{keyword} :abc\n ensure\n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n ensure\n #{keyword} 'abc'\n end").should be_true
-        described_class.void_value_expression?("begin\n 1\n ensure\n #{keyword} :abc\n 1\n end").should be_false
-      end
-
-      # with ensure and rescue
-      described_class.void_value_expression?("begin\n 1\n          rescue\n 2\n          ensure\n 3\n          end").should be_false
-      described_class.void_value_expression?("begin\n #{keyword}\n rescue\n 2\n          ensure\n 3\n          end").should be_true
-      described_class.void_value_expression?("begin\n 1\n          rescue\n #{keyword}\n ensure\n 3\n          end").should be_true
-      described_class.void_value_expression?("begin\n 1\n          rescue\n 2\n          ensure\n #{keyword}\n end").should be_true
-    end
-  end
-
-  it_should_behave_like 'single line void_value_expression?', 'return'
-  it_should_behave_like 'single line void_value_expression?', 'next'
-  it_should_behave_like 'single line void_value_expression?', 'break'
-
-  it_should_behave_like 'single line void_value_expression?', 'redo',  no_args: true
-  it_should_behave_like 'single line void_value_expression?', 'retry', no_args: true
-
   it 'knows when a line opens the data segment' do
     described_class.begins_data_segment?('__END__').should be_true
     described_class.begins_data_segment?('__ENDS__').should be_false
   end
-
-  it 'knows when the next line modifies the current line' do
-    described_class.next_line_modifies_current?('.meth').should be_true
-    described_class.next_line_modifies_current?(' .meth').should be_true
-
-    described_class.next_line_modifies_current?('meth').should be_false
-    described_class.next_line_modifies_current?(' meth').should be_false
-  end
 end