seeing_is_believing 3.0.0.beta.4 → 3.0.0.beta.5

data/spec/binary/engine_spec.rb

@@ -0,0 +1,97 @@
+require 'seeing_is_believing/binary/engine'
+require 'seeing_is_believing/binary/config'
+
+class SeeingIsBelieving
+  module Binary
+    RSpec.describe Engine do
+      def call(body, options={})
+        timeout  = options.fetch :timeout, 0
+        filename = options.fetch :filename, "program.rb"
+        config   = Config.new body: body, timeout_seconds: timeout
+        config.lib_options.timeout_seconds = timeout
+        config.lib_options.filename        = filename
+        Engine.new config
+      end
+
+      def assert_must_evaluate(message)
+        engine = call ''
+        expect { engine.__send__ message }.to raise_error MustEvaluateFirst, /#{message}/
+        engine.evaluate!
+        engine.__send__ message
+      end
+
+      context 'syntax' do
+        let(:valid_engine)   { call "1+1", filename: "filename.rb" }
+        let(:invalid_engine) { call "1+",  filename: "filename.rb" }
+
+        specify 'syntax_error? is true when the body was syntactically invalid' do
+          expect(  valid_engine.syntax_error?).to eq false
+          expect(invalid_engine.syntax_error?).to eq true
+        end
+
+        specify 'syntax_error contains the syntax\'s error message with file and line information' do
+          expect(valid_engine.syntax_error).to eq nil
+
+          allow_any_instance_of(Code::Syntax).to receive(:error_message).and_return "ERR!!"
+          allow_any_instance_of(Code::Syntax).to receive(:line_number).and_return   123
+          expect(invalid_engine.syntax_error)
+            .to eq SyntaxErrorMessage.new(line_number: 123, filename: "filename.rb", explanation: "ERR!!")
+        end
+      end
+
+      context 'cleaned_body' do
+        it 'has the annotations removed' do
+          expect(call("1 # =>").cleaned_body).to eq "1"
+        end
+        it 'ends in a newline if the body ended in a newline' do
+          expect(call("1").cleaned_body).to eq "1"
+          expect(call("1\n").cleaned_body).to eq "1\n"
+        end
+      end
+
+      context 'before evaluating it raises if asked for' do
+        specify('result')               { assert_must_evaluate :result }
+        specify('exitstatus')            { assert_must_evaluate :exitstatus }
+        specify('timed_out?')            { assert_must_evaluate :timed_out? }
+        specify('annotated_body')        { assert_must_evaluate :annotated_body }
+      end
+
+      context 'after evaluating' do
+        specify 'result is the result of the evaluation' do
+          status = call('exit 55').evaluate!.result.exitstatus
+          expect(status).to eq 55
+        end
+
+        it 'has recorded the exitstatus' do
+          engine = call('exit 88')
+          engine.evaluate!
+          expect(engine.exitstatus).to eq 88
+        end
+
+        specify 'timed_out? is true if the program raised a Timeout::Error' do
+          expect(call('', timeout: 1).evaluate!.timed_out?).to eq false
+          expect(call('sleep 1', timeout: 0.01).evaluate!.timed_out?).to eq true
+        end
+
+        context 'annotated_body' do
+          it 'is the body after being run through the annotator' do
+            expect(call("1").evaluate!.annotated_body).to eq "1  # => 1"
+          end
+          it 'ends in a newline if the body ended in a newline' do
+            expect(call("1").evaluate!.annotated_body).to eq "1  # => 1"
+            expect(call("1\n").evaluate!.annotated_body).to eq "1  # => 1\n"
+          end
+        end
+
+        it 'evaluation errors are raised up, and it behaves as if it was not evaluated' do
+          evaluated   = call('1').evaluate!
+          unevaluated = call '1'
+          expect(SeeingIsBelieving).to receive(:call).exactly(2).times.and_raise(ArgumentError)
+          evaluated.evaluate!
+          expect { unevaluated.evaluate! }.to raise_error ArgumentError
+          expect { unevaluated.evaluate! }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+end

data/spec/binary/{comment_formatter_spec.rb → format_comment_spec.rb}

@@ -1,9 +1,9 @@
 # encoding: utf-8
 
 require 'spec_helper'
-require 'seeing_is_believing/binary/comment_formatter'
+require 'seeing_is_believing/binary/format_comment'
 
-RSpec.describe SeeingIsBelieving::Binary::CommentFormatter do
+RSpec.describe SeeingIsBelieving::Binary::FormatComment do
   def result_for(line_length, separator, result, options={})
     described_class.new(line_length, separator, result, options).call
   end

data/spec/binary/marker_spec.rb

@@ -0,0 +1,71 @@
+require 'seeing_is_believing/binary/data_structures'
+
+RSpec.describe SeeingIsBelieving::Binary::Marker do
+
+  describe 'to_regex' do
+    def assert_parses(input, regex)
+      expect(described_class.to_regex input).to eq regex
+    end
+
+    it 'doesn\'t change existing regexes' do
+      assert_parses /^.$/ix, /^.$/ix
+    end
+
+    it 'converts strings into regexes' do
+      assert_parses '',    %r()
+      assert_parses 'a',   %r(a)
+    end
+
+    it 'ignores surrounding slashes' do
+      assert_parses '//',  %r()
+      assert_parses '/a/', %r(a)
+    end
+
+    it 'respects flags after the trailing slash in surrounding slashes' do
+      assert_parses '/a/',     %r(a)
+      assert_parses '/a//',    %r(a/)
+      assert_parses '//a/',    %r(/a)
+      assert_parses '/a/i',    %r(a)i
+      assert_parses '/a/im',   %r(a)im
+      assert_parses '/a/xim',  %r(a)xim
+      assert_parses '/a/mix',  %r(a)mix
+      assert_parses '/a/mixi', %r(a)mixi
+    end
+
+    it 'isn\'t fooled by strings that kinda look regexy' do
+      assert_parses '/a',  %r(/a)
+      assert_parses 'a/',  %r(a/)
+      assert_parses '/',   %r(/)
+      assert_parses '/i',  %r(/i)
+    end
+
+    it 'does not escape the content' do
+      assert_parses 'a\\s+',   %r(a\s+)
+      assert_parses '/a\\s+/', %r(a\s+)
+    end
+  end
+
+  it 'requires prefix and a regex' do
+    described_class.new prefix: '', regex: //
+    expect { described_class.new }.to raise_error
+    expect { described_class.new prefix: ''  }.to raise_error
+    expect { described_class.new regex:  // }.to raise_error
+  end
+
+  it 'stores the prefix and a regex' do
+    marker = described_class.new(prefix: 't', regex: /r/)
+    expect(marker.prefix).to eq 't'
+    expect(marker.regex).to eq /r/
+  end
+
+  it 'converts strings to rgexes when they are set' do
+    marker = described_class.new prefix: 't', regex: 'r1'
+    expect(marker[:regex]).to eq /r1/
+
+    marker.regex = '/r2/i'
+    expect(marker.regex).to eq /r2/i
+
+    marker[:regex] = 'r3'
+    expect(marker.regex).to eq /r3/
+  end
+end

data/spec/binary/remove_annotations_spec.rb

@@ -1,20 +1,19 @@
 require 'spec_helper'
 require 'seeing_is_believing/binary/remove_annotations'
-require 'seeing_is_believing/binary/parse_args'  # for marker info
+require 'seeing_is_believing/binary/data_structures'
 
 RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
+  def regexes
+    SeeingIsBelieving::Binary::Markers.new
+  end
+
   def call(code, should_clean_values=true)
     indentation = code[/\A */]
     code        = code.gsub /^#{indentation}/, ''
+    code << "\n" unless code.end_with? "\n"
     described_class.call(code, should_clean_values, regexes).chomp
   end
 
-  def regexes
-    SeeingIsBelieving::Binary::ParseArgs
-      .marker_regexes
-      .each_with_object({}) { |(name, str), rs| rs[name] = Regexp.new str }
-  end
-
   context 'when there are lines that are just normal comments' do
     example { expect(call "1 # hello").to eq "1 # hello" }
     example { expect(call "1 # hello\n"\
@@ -31,17 +30,19 @@ RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
     example { expect(call "1  # => 1",  true).to eq "1"   }
     example { expect(call "1   # => 1", true).to eq "1"   }
     example { expect(call "1  # =>  1", true).to eq "1"   }
+    example { expect(call "1  #  => 1", true).to eq "1"   }
     example { expect(call "\n1 # => 1", true).to eq "\n1" }
   end
 
-  context 'when told not to clean out value annotations' do
-    example { expect(call "1# => 1",    false).to eq "1# => 1"    }
-    example { expect(call "1 # => 1",   false).to eq "1 # => 1"   }
-    example { expect(call "1  # => 1",  false).to eq "1  # => 1"  }
-    example { expect(call "1  # => 1",  false).to eq "1  # => 1"  }
-    example { expect(call "1   # => 1", false).to eq "1   # => 1" }
-    example { expect(call "1  # =>  1", false).to eq "1  # =>  1" }
-    example { expect(call "\n1 # => 1", false).to eq "\n1 # => 1" }
+  context 'when told not to clean out value markers, it leaves the marker, but removes the annotation and trailing whitespace' do
+    example { expect(call "1# => 1",    false).to eq "1# =>"    }
+    example { expect(call "1 # => 1",   false).to eq "1 # =>"   }
+    example { expect(call "1  # => 1",  false).to eq "1  # =>"  }
+    example { expect(call "1  # => 1",  false).to eq "1  # =>"  }
+    example { expect(call "1   # => 1", false).to eq "1   # =>" }
+    example { expect(call "1  # =>  1", false).to eq "1  # =>"  }
+    example { expect(call "1  #  => 1", false).to eq "1  #  =>" }
+    example { expect(call "\n1 # => 1", false).to eq "\n1 # =>" }
   end
 
   context 'cleaning inline exception annotations' do
@@ -53,8 +54,8 @@ RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
     example { expect(call "1  # ~>  1").to eq "1"   }
     example { expect(call "\n1 # ~> 1").to eq "\n1" }
 
-    example { expect(call "# >> 1").to eq ""        }
-    example { expect(call "# !> 1").to eq ""        }
+    example { expect(call "# >> 1").to   eq ""      }
+    example { expect(call "# !> 1").to   eq ""      }
   end
 
   context 'cleaning multiline results' do
@@ -143,7 +144,7 @@ RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
 
       expect(call "1# => 2\n"\
                   " #    3",
-                  false).to eq "1# => 2"
+                  false).to eq "1# =>"
     end
 
     it 'works on inline exceptions' do
@@ -188,6 +189,12 @@ RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
     # >> 2
     # >> 3
     CODE
+
+    example { expect(call <<-CODE.gsub(/^\s*/, '')).to eq "\n1" }
+
+    # >> err
+    1
+    CODE
   end
 
   context 'cleaning stderr annotations' do
@@ -217,6 +224,12 @@ RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
     # !> 2
      # !> 2
     CODE
+
+    example { expect(call <<-CODE.gsub(/^\s*/, '')).to eq "\n1" }
+
+    # !> err
+    1
+    CODE
   end
 
 

data/spec/binary/rewrite_comments_spec.rb

@@ -3,7 +3,8 @@ require 'seeing_is_believing/binary/rewrite_comments'
 
 RSpec.describe SeeingIsBelieving::Binary::RewriteComments do
   def call(code, options={}, &block)
-    described_class.call code, options, &block
+    code = code + "\n" unless code.end_with? "\n"
+    described_class.call(code, options, &block).chomp
   end
 
   it 'ignores multiline comments' do
@@ -57,9 +58,10 @@ RSpec.describe SeeingIsBelieving::Binary::RewriteComments do
     rewritten = call("'a'\n"\
                      "'b'\n"\
                      "'c' # c\n"\
-                     "'d'",
-                     always_rewrite: [2, 3]) do |c|
-                       value = sprintf "%d|%d|%p|%d|%p|%d..%d|%d..%d|%d..%d",
+                     "'d' \n"\
+                     "'e'",
+                     include_lines: [2, 3, 4, 5]) do |c|
+                       value = sprintf "%d|%d|%p|%d|%p|%d...%d|%d...%d|%d...%d",
                                        c.line_number,
                                        c.whitespace_col,
                                        c.whitespace,
@@ -75,17 +77,30 @@ RSpec.describe SeeingIsBelieving::Binary::RewriteComments do
                      end
     expect(rewritten).to eq \
       "'a'\n"\
-      "'b'pre2|3|\"\"|3|\"\"|7..7|7..7|7..7\n"\
-      "'c'pre3|3|\" \"|4|\"# c\"|11..15|11..12|12..15\n"\
-      "'d'"
+      "'b'pre2|3|\"\"|3|\"\"|7...7|7...7|7...7\n"\
+      "'c'pre3|3|\" \"|4|\"# c\"|11...15|11...12|12...15\n"\
+      "'d'pre4|3|\" \"|4|\"\"|19...20|19...20|20...20\n"\
+      "'e'pre5|3|\"\"|3|\"\"|24...24|24...24|24...24"
 
-    rewritten = call("", always_rewrite: [1]) { |c| ['a', 'b'] }
+    rewritten = call("", include_lines: [1]) { |c| ['a', 'b'] }
     expect(rewritten).to eq "ab"
 
-    rewritten = call("a", always_rewrite: [1]) { |c| ['b', 'c'] }
+    rewritten = call("a", include_lines: [1]) { |c| ['b', 'c'] }
     expect(rewritten).to eq "abc"
 
-    rewritten = call("a\n", always_rewrite: [1]) { |c| ['b', 'c'] }
-    expect(rewritten).to eq "abc\n"
+    rewritten = call("a ", include_lines: [1]) { |c| ['b', 'c'] }
+    expect(rewritten).to eq "abc"
+  end
+
+  it 'does not include lines that are uncommentable' do
+    rewritten = call("'a\n"\
+                     "b'",
+                     include_lines: [1, 2]) { ["whitespace", "comment"] }
+    expect(rewritten).to eq "'a\n"\
+                            "b'whitespacecomment"
+  end
+
+  it 'blows up if given unknown options' do
+    expect { call '1', not_an_option: nil }.to raise_error /not_an_option/
   end
 end

data/spec/code_spec.rb

@@ -1,12 +1,196 @@
-# require 'seeing_is_believing/code'
+require 'seeing_is_believing/code'
+
+RSpec.describe SeeingIsBelieving::Code do
+  def code_for(raw_code, options={})
+    manage_newline = options.fetch :nl, true
+    raw_code += "\n" if manage_newline && !raw_code.end_with?("\n")
+    described_class.new(raw_code)
+  end
+
+  def assert_range(range, begin_pos, end_pos)
+    expect(range.begin_pos).to eq begin_pos
+    expect(range.end_pos).to eq end_pos
+  end
+
+  it 'raises a SyntaxError if given a file that does not end in a newline' do
+    code_for "\n", nl: false
+    expect { code_for "", nl: false  }.to raise_error SyntaxError, /newline/i
+
+    code_for "1\n", nl: false
+    expect { code_for "1", nl: false }.to raise_error SyntaxError, /newline/i
+  end
+
+  describe '#range_for' do
+    it 'returns a range object with the specified start and ends' do
+      code  = code_for "abcd"
+      range = code.range_for(1, 2)
+      expect(range.begin_pos).to eq 1
+      expect(range.end_pos).to eq 2
+      expect(range.source).to eq 'b'
+    end
+  end
+
+  describe '#root' do
+    it 'returns the root for valid code' do
+      expect(code_for('1').root.type).to eq :int
+    end
+    it 'returns a null root for invalid code' do
+      root = code_for('"').root
+      expect(root.type).to eq :null_node
+      assert_range root.location.expression, 0, 0
+    end
+    it 'returns a null root for empty code' do
+      root = code_for('').root
+      expect(root.type).to eq :null_node
+      assert_range root.location.expression, 0, 0
+    end
+  end
+
+  describe '#index_to_linenum' do
+    it 'treats indexes as 0based and lines as 1based' do
+      code = code_for "xx\nyyy\n\nzz"
+      [[1,0], [1,1], [1,2],
+       [2,3], [2,4], [2,5], [2,6],
+       [3,7],
+       [4,8], [4,9],
+      ].each do |expected_lineno, index|
+        actual_lineno = code.index_to_linenum index
+        expect(expected_lineno).to eq(actual_lineno),
+          "index:           #{index}\n"\
+          "expected lineno: #{expected_lineno}\n"\
+          "actual lineno:   #{actual_lineno.inspect}"
+      end
+    end
+
+    it 'considers any indexes after the end to be on the last line' do
+      expect(code_for("a\nb\nc\n").index_to_linenum(1000)).to eq 4
+    end
+  end
+
+  describe '#linenum_to_index' do
+    it 'treats line numebrs as 1based and indexes as 0based' do
+      code = code_for "xx\nyyy\n\nzz\n"
+      expect(code.linenum_to_index 1).to eq 0
+      expect(code.linenum_to_index 2).to eq 3
+      expect(code.linenum_to_index 3).to eq 7
+      expect(code.linenum_to_index 4).to eq 8
+      expect(code.linenum_to_index 5).to eq 11
+    end
+
+    it 'considers any lines past the end to be at 1 character after the last index' do
+      expect(code_for("abc\n").linenum_to_index(100)).to eq 4
+    end
+  end
+
+  # should it begin after magic comments and stuff?
+  describe '#body_range' do
+    it 'returns a range for the whole body' do
+      assert_range code_for("\n").body_range, 0, 1
+      assert_range code_for("1\n").body_range, 0, 2
+      assert_range code_for("1111\n").body_range, 0, 5
+    end
+
+    it 'ends after the last token prior to __END__ statements' do
+      assert_range code_for("__END__\n").body_range, 0, 0
+      assert_range code_for("\n__END__\n").body_range, 0, 1
+      assert_range code_for("a\n__END__\n").body_range, 0, 2
+      assert_range code_for("a\n\n\n__END__\n").body_range, 0, 2
+    end
+
+    it 'ends after trailing comments' do
+      assert_range code_for("1#a\n").body_range, 0, 4
+      assert_range code_for("1#a\n#b\n#c\n").body_range, 0, 10
+      assert_range code_for("1#a\n#b\n#c\n\n").body_range, 0, 10
+      assert_range code_for("a\n#c\n\n__END__\n").body_range, 0, 5
+      assert_range code_for("1#a\n#b\n#c\n__END__\n").body_range, 0, 10
+      assert_range code_for("1#a\n#b\n#c\n\n__END__\n").body_range, 0, 10
+    end
+
+    it 'ends after heredocs' do
+      assert_range code_for("<<a\nb\na\n").body_range, 0, 8
+      assert_range code_for("<<a\nb\na\n1\n").body_range, 0, 10
+      assert_range code_for("<<a\nb\na\n#c\n").body_range, 0, 11
+    end
+  end
+
+  describe 'void value expressions' do
+    def void_value?(ast)
+      code_for("\n").void_value?(ast)
+    end
+
+    def ast_for(code)
+      Parser::CurrentRuby.parse code
+    end
+
+    it 'knows a `return`, `next`, `redo`, `retry`, and `break` are void values' do
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      expect(void_value?(ast_for "123")).to be false
+    end
+  end
+
+end
+
 
-# RSpec.describe 'SeeingIsBelieving::Code' do
-#   describe '#range' do
-#     it 'returns a range object with the specified start and ends'
-#   end
 
 #   describe '#inline_comments' do
-#     it 'finds their line_number, column_number, preceding_whitespace, text, preceding_whitespace_range, and comment_range' do
+#     xit 'finds their line_number, column_number, preceding_whitespace, text, preceding_whitespace_range, and comment_range' do
 #       code = code_for <<-CODE.gsub(/^\s*/, '')
 #       # c1
 #       not c