seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/spec/hard_core_ensure_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'ichannel'
 require 'seeing_is_believing/hard_core_ensure'
 
-describe SeeingIsBelieving::HardCoreEnsure do
+RSpec.describe SeeingIsBelieving::HardCoreEnsure do
   def call(options)
     described_class.new(options).call
   end

data/spec/seeing_is_believing_spec.rb

@@ -1,10 +1,26 @@
 # -*- coding: utf-8 -*-
 require 'spec_helper'
-require 'seeing_is_believing'
 require 'stringio'
+require 'seeing_is_believing'
+require 'seeing_is_believing/evaluate_with_eval_in'
+
+RSpec.describe SeeingIsBelieving do
+  def method_result(name)
+    @result = def __some_method__; end
+    if :__some_method__ == @result
+      name.inspect
+    elsif nil == @result
+      nil.inspect
+    else
+      raise "huh? #{@result.inspect}"
+    end
+  end
 
-describe SeeingIsBelieving do
   def invoke(input, options={})
+    if options[:debug]
+      options.delete :debug
+      options[:debugger] = SeeingIsBelieving::Debugger.new(stream: $stderr, colour: true)
+    end
     described_class.new(input, options).call
   end
 
@@ -14,6 +30,10 @@ describe SeeingIsBelieving do
 
   let(:proving_grounds_dir) { File.expand_path '../../proving_grounds', __FILE__ }
 
+  it 'evaluates with EvaluateByMovingFiles by default' do
+    expect(values_for "`echo 1`").to eq [['"1\n"']] # shows we're not using the only other option (EvaluateWithEvalIn)
+  end
+
   it 'takes a string and returns a result of the line numbers (counting from 1) and each inspected result from that line' do
     input  = "10+10\n'2'+'2'"
     expect(invoke(input)[1]).to eq ["20"]
@@ -25,6 +45,16 @@ describe SeeingIsBelieving do
     expect(invoke(input)[1]).to eq ['"NUM"']
   end
 
+  it 'allows uers to pass in their own inspection recorder' do
+    wrapper = lambda { |program, num_captures|
+      SeeingIsBelieving::InspectExpressions.call \
+        program,
+        num_captures,
+        after_each: -> line_number { ").tap { $SiB.record_result(:inspect, #{line_number}, 'zomg') }" }
+    }
+    expect(invoke(':body', record_expressions: wrapper)[1]).to eq ['"zomg"']
+  end
+
   it 'remembers context of previous lines' do
     expect(values_for("a=12\na*2")).to eq [['12'], ['24']]
   end
@@ -51,8 +81,8 @@ describe SeeingIsBelieving do
   it 'evalutes to an empty array for lines that it cannot understand' do
     expect(values_for("[3].map \\\ndo |n|\n n*2\n end")).to eq [['[3]'], [], ['6'], ['[6]']]
     expect(values_for("'\n1\n'")).to eq [[], [], ['"\n1\n"']]
-    expect(values_for("<<HEREDOC\n\n1\nHEREDOC")).to eq  [[%Q'"\\n1\\n"']] # newlines escaped b/c lib inspects them
-    expect(values_for("<<-HEREDOC\n\n1\nHEREDOC")).to eq [[%Q'"\\n1\\n"']]
+    expect(values_for("<<HEREDOC\n\n1\nHEREDOC")).to eq  [[%Q'"\\n1\\n"'], [], [], []] # newlines escaped b/c lib inspects them
+    expect(values_for("<<-HEREDOC\n\n1\nHEREDOC")).to eq [[%Q'"\\n1\\n"'], [], [], []]
   end
 
   it 'records the targets of chained methods' do
@@ -65,8 +95,8 @@ describe SeeingIsBelieving do
   end
 
   it "records heredocs" do
-    expect(values_for("<<A\n1\nA")).to eq [[%'"1\\n"']]
-    expect(values_for("<<-A\n1\nA")).to eq [[%'"1\\n"']]
+    expect(values_for("<<A\n1\nA")).to  eq [[%'"1\\n"'], [], []]
+    expect(values_for("<<-A\n1\nA")).to eq [[%'"1\\n"'], [], []]
   end
 
   it 'does not insert code into the middle of heredocs' do
@@ -105,10 +135,7 @@ describe SeeingIsBelieving do
     expect(result.exception.message).to eq 'omg!'
 
     expect(result[1]).to eq ['12']
-
     expect(result[2]).to eq []
-    expect(result[2].exception).to eq result.exception
-
     expect(result[3]).to eq []
   end
 
@@ -128,11 +155,11 @@ describe SeeingIsBelieving do
 
                         # comment
                         __LINE__')
-    ).to eq [['1'], ['2'], [], [], ['5'], [], ['5'], [], [], ['10']]
+    ).to eq [['1'], ['2'], [], [], ['5'], [method_result(:meth)], ['5'], [], [], ['10']]
   end
 
   it 'records return statements' do
-    expect(values_for("def meth \n return 1          \n end \n meth")).to eq [[], ['1'], [], ['1']]
+    expect(values_for("def meth \n return 1          \n end \n meth")).to eq [[], ['1'], [method_result(:meth)], ['1']]
     expect(values_for("-> {  \n return 1          \n }.call"        )).to eq [[], ['1'], ['1']]
     expect(values_for("-> { return 1 }.call"                        )).to eq [['1']]
 
@@ -149,7 +176,7 @@ describe SeeingIsBelieving do
   end
 
   it 'does not try to record the keyword redo' do
-    expect(values_for(<<-DOC)).to eq [[], ['0'], ['0...3'], ['1', '2', '3', '4'], ['false', 'true', 'false', 'false'], ['0...3'], [], ['0...3']]
+    expect(values_for(<<-DOC)).to eq [[], ['0'], ['0...3'], ['1', '2', '3', '4'], ['false', 'true', 'false', 'false'], ['0...3'], [method_result(:meth)], ['0...3']]
       def meth
         n = 0
         for i in 0...3
@@ -162,7 +189,7 @@ describe SeeingIsBelieving do
   end
 
   it 'does not try to record the keyword retry' do
-    expect(values_for(<<-DOC)).to eq [[], [], [], [], ['nil']]
+    expect(values_for(<<-DOC)).to eq [[], [], [], [method_result(:meth)], ['nil']]
       def meth
       rescue
         retry
@@ -228,7 +255,7 @@ describe SeeingIsBelieving do
   end
 
   it 'does not capture output from __END__ onward' do
-    expect(values_for("1+1\nDATA.read\n__END__\n....")).to eq [['2'], ['"....\n"']] # <-- should this actually write a newline on the end?
+    expect(values_for("1+1\nDATA.read\n__END__\n....")).to eq [['2'], ['"....\n"'], [], []] # <-- should this actually write a newline on the end?
   end
 
   it 'raises a SyntaxError when the whole program is invalid' do
@@ -250,7 +277,7 @@ describe SeeingIsBelieving do
   it 'can deal with methods that are invoked entirely on the next line' do
     expect(values_for("a = 1\n.even?\na")).to eq [['1'], ['false'], ['false']]
     expect(values_for("a = 1.\neven?\na")).to eq [['1'], ['false'], ['false']]
-    expect(values_for("1\n.even?\n__END__")).to eq [['1'], ['false']]
+    expect(values_for("1\n.even?\n__END__")).to eq [['1'], ['false'], []] # TODO: would be nice if we could consolidate this shit so we could find out things like __END__ without repeatedly parsing, I'd prefer if this did not imply there were results on this line -.-
   end
 
   it 'does not record leading comments' do
@@ -278,7 +305,7 @@ describe SeeingIsBelieving do
 
   it "doesn't fuck up when there are lines with magic comments in the middle of the app" do
     expect(values_for '1+1
-                       # encoding: wtf').to eq [['2']]
+                       # encoding: wtf').to eq [['2'], []]
   end
 
   it "doesn't remove multiple leading comments" do
@@ -321,12 +348,10 @@ describe SeeingIsBelieving do
       File.write 'omg-ruby', "#!/usr/bin/env ruby
         $LOAD_PATH.unshift '#{File.expand_path '../../lib', __FILE__}'
 
-        require 'seeing_is_believing'
-        result = SeeingIsBelieving::Result.new
-        result.record_result(1, /omg/)
-
-        require 'json'
-        puts JSON.dump result.to_primitive
+        require 'seeing_is_believing/event_stream/producer'
+        sib = SeeingIsBelieving::EventStream::Producer.new($stdout)
+        sib.record_result(:inspect, 1, /omg/)
+        sib.finish!
       "
       File.chmod 0755, 'omg-ruby'
       old_path = ENV['PATH']
@@ -339,21 +364,47 @@ describe SeeingIsBelieving do
     end
   end
 
-  it 'does not record BEGIN and END', not_implemented: true do
-    pending 'not implemented'
-    expect { invoke <<-CODE }.to_not raise_error
-      puts 1
-      BEGIN {
-        puts "begin code"
-        some_var = 2
-      }
-      puts 3
-      END {
-        puts "end code"
-        puts some_var
-      }
-      puts 4
-    CODE
+  describe 'BEGIN and END' do
+    it 'Executes in the appropriate order' do
+      pending 'not implemented'
+      expect(invoke <<-CODE).stdout.to eq "1\n2\n3\n4\n5\n6\n7\n8\n9\n"
+        p 3
+        END   { p 8 }
+        p 4
+        BEGIN { p 1 }
+        p 5
+        END   { p 9 }
+        p 6
+        BEGIN { p 2 }
+        p 7
+      CODE
+    end
+
+    it 'Maintains correct line numbers' do
+      pending 'not implemented'
+      expected_values = [
+        ['1'],
+        [],
+        ['3'],
+        [],
+        ['5'],
+        [],
+        ['7'],
+        [],
+        ['9'],
+      ]
+      expect(values_for <<-CODE).to eq expected_values
+        __LINE__
+        BEGIN {
+          __LINE__
+        }
+        __LINE__
+        END {
+          __LINE__
+        }
+        __LINE__
+      CODE
+    end
   end
 
   # For more info about this one
@@ -367,12 +418,19 @@ describe SeeingIsBelieving do
     result = invoke(%[def self.inspect
                         self
                       end
-                      self], filename: 'blowsup.rb')
+                      self], filename: 'blowsup.rb') # TODO This actually writes the file into the root of SiB
     expect(result).to have_exception
     expect(result.exception.class_name).to eq 'SystemStackError'
     expect(result.exception.backtrace.grep(/blowsup.rb/)).to_not be_empty # backtrace includes a line that we can show
     expect(result.exception.message).to match /recursive/i
-    expect(result[4].exception).to eq result.exception
+  end
+
+  it 'makes the SeeingIsBelieving::VERSION available to the program' do
+    expect(values_for "SeeingIsBelieving::VERSION").to eq [[SeeingIsBelieving::VERSION.inspect]]
+  end
+
+  it 'does not change the number of lines in the file' do
+    expect(values_for "File.read(__FILE__).lines.count").to eq [['1']]
   end
 
   context 'when given a debugger' do
@@ -392,8 +450,47 @@ describe SeeingIsBelieving do
     it 'prints the result' do
       call
       expect(stream.string).to include "RESULT:"
-      expect(stream.string).to include '1=>#<SIB:Line["1"] (1, 1) no exception>'
+      expect(stream.string).to include 'SIB::Result'
+      expect(stream.string).to include '@results={'
     end
     # should ProgramRewriter have some debug options?
   end
+
+  context 'when :evaluator option is set' do
+    require 'webmock'
+    WebMock.disable_net_connect!
+
+    include WebMock::API
+    before { WebMock.reset! }
+
+    it 'can use EvaluateByMovingFiles' do
+      # shows we're not using the only other option (EvaluateWithEvalIn)
+      expect(values_for "`echo 1`", evaluator: SeeingIsBelieving::EvaluateByMovingFiles).to eq [['"1\n"']]
+    end
+
+    it 'can use EvaluateWithEvalIn' do
+      require 'seeing_is_believing/event_stream/producer'
+      redirect_url     = 'https://example.com/whatever'
+      api_redirect_url = redirect_url + '.json'
+
+      stream   = StringIO.new
+      producer = SeeingIsBelieving::EventStream::Producer.new(stream)
+      producer.record_result :inspect, 1, "a"
+      producer.record_result :inspect, 1, "b"
+      producer.record_result :inspect, 2, "c"
+      producer.finish!
+
+      response = { 'lang'          => 'whatever',
+                   'lang_friendly' => 'whatever',
+                   'code'          => 'whatever',
+                   'output'        => stream.string,
+                   'status'        => 'OK (0.012 sec real, 0.013 sec wall, 7 MB, 22 syscalls)'}
+
+      stub_request(:post, 'https://eval.in/').to_return(status: 302, headers: {'Location' => redirect_url})
+      stub_request(:get,    api_redirect_url).to_return(status: 200, body: JSON.dump(response))
+
+      values = values_for "whatever", evaluator: SeeingIsBelieving::EvaluateWithEvalIn
+      expect(values).to eq [['"a"', '"b"'], ['"c"']]
+    end
+  end
 end

data/spec/spec_helper.rb

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

data/spec/wrap_expressions_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'seeing_is_believing/wrap_expressions'
 
-describe SeeingIsBelieving::WrapExpressions do
+RSpec.describe SeeingIsBelieving::WrapExpressions do
   def wrap(code)
     described_class.call code,
       before_each: -> * { '<' },
@@ -17,23 +17,36 @@ describe SeeingIsBelieving::WrapExpressions do
   end
 
   describe 'wrapping the body' do
-    let(:options) { { before_all: "[",
-                      after_all:  "]",
-                      before_each: -> * { '<' },
-                      after_each:  -> * { '>' } } }
+    let(:options) { { before_all: -> { "[".freeze },
+                      after_all:  -> { "]".freeze },
+                      before_each: -> * { '<'.freeze },
+                      after_each:  -> * { '>'.freeze } } }
 
     it 'wraps the entire body, ignoring leading comments and the data segment' do
       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
-      expect(described_class.call("# abc", options)).to eq "# abc"
+    it 'comes in on blank lines' do
+      expect(described_class.call('', options)).to eq '[]'
+    end
+
+    it 'comes in first when there are only comments' do
+      expect(described_class.call("# abc", options)).to eq "[]# abc"
     end
 
     it 'comes in before trailing comments' do
       expect(described_class.call("1# abc", options)).to eq "[<1>]# abc"
     end
 
+    # this changes the number of lines, annoyingly, though it shouldn't mess anything up,
+    # unless you were trying to reopen the file to read it, in which case, *surprise* the whole thing's been rewritten
+    it 'injects a newline if there is a data segment and the after block doesn\'t end in a newline' do
+      expect(described_class.call("__END__", options)).to eq "[]\n__END__"
+      expect(described_class.call("\n__END__", options)).to eq "[]\n__END__"
+      expect(described_class.call("\n\n__END__", options)).to eq "[]\n\n__END__"
+      expect(described_class.call("__END__!", options)).to eq "[<__END__!>]"
+    end
+
     it 'wraps bodies that are wrapped in parentheses' do
       expect(wrap('(1)')).to eq '<(1)>'
       expect(wrap("(\n<<doc\ndoc\n)")).to eq "<(\n<<<doc>\ndoc\n)>"
@@ -71,9 +84,9 @@ describe SeeingIsBelieving::WrapExpressions do
                                   "end",
                                   options)
             ).to eq "[<a>\n"\
-                    "def b\n"\
+                    "<def b\n"\
                     "  <c = 1>\n"\
-                    "end]"
+                    "end>]"
     end
   end
 
@@ -185,8 +198,8 @@ describe SeeingIsBelieving::WrapExpressions do
     end
 
     it 'does not wrap multiple expressions when they constitute a void value' do
-      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"
+      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
@@ -519,19 +532,19 @@ describe SeeingIsBelieving::WrapExpressions do
     end
 
     it 'does not wrap if the last value in any portion is a void value expression' do
-      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"
+      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
-      expect(wrap("def a\nreturn if 1\nend")).to eq "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
@@ -781,37 +794,37 @@ describe SeeingIsBelieving::WrapExpressions do
   end
 
   describe 'method definitions' do
-    it 'does not wrap the definition or arguments' do
-      expect(wrap("def a(b,c=1,*d,&e)\nend")).to eq "def a(b,c=1,*d,&e)\nend"
+    it 'does wraps the definition, but not the arguments' do
+      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
-      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"
+      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
-      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"
+    it 'wrap singleton method definitions' do
+      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
-      expect(wrap("def a\nyield\nend")).to eq "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
-      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"
+      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
-      expect(wrap("def a\nreturn 1\nend")).to eq "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
-      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"
+      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
 
@@ -836,7 +849,7 @@ describe SeeingIsBelieving::WrapExpressions do
   describe 'BEGIN/END' do
     # not implemented b/c we cannot wrap around these either.
     # So what does it mean to wrap around?
-    # mabe this?
+    # maybe this?
     #   1
     #   BEGIN {}
     #   2