seeing_is_believing 0.0.3 → 0.0.4

data/spec/seeing_is_believing_spec.rb

@@ -14,6 +14,8 @@ describe SeeingIsBelieving do
     StringIO.new string
   end
 
+  let(:proving_grounds_dir) { File.expand_path '../../proving_grounds', __FILE__ }
+
   it 'takes a string or stream 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'"
     output = [[1, ["2"]], [2, ['"22"']]]
@@ -88,6 +90,12 @@ describe SeeingIsBelieving do
 
     values_for("1 +
                     2").should == [[], ['3']]
+
+    values_for("'\n1\n'").should == [[], [], ['"\n1\n"']]
+
+    # 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"']]
   end
 
   it 'does not record expressions that end in a comment' do
@@ -98,26 +106,101 @@ describe SeeingIsBelieving do
 
   it 'has no output for empty lines' do
     values_for('').should == [[]]
+    values_for('  ').should == [[]]
+    values_for("  \n").should == [[]]
     values_for("1\n\n2").should == [['1'],[],['2']]
   end
 
   it 'stops executing on errors and reports them' do
-    result = values_for("12\nraise Exception, 'omg!'\n12")
-    result[0].should == ['12']
+    invoke("'no exception'").should_not have_exception
 
-    result[1].size.should == 1
-    exception = result[1].first
-    exception.class.should == Exception
-    exception.message.should == 'omg!'
+    result = invoke("12\nraise Exception, 'omg!'\n12")
+    result.should have_exception
+    result.exception.message.should == 'omg!'
+
+    result[1].should == ['12']
 
     result[2].should == []
-    result.size.should == 3
+    result[2].exception.should == result.exception
+
+    result[3].should == []
+    result.to_a.size.should == 3
+
+    pending 'Not sure how to force the backtrace to render' do
+      result.exception.backtrace.should be_a_kind_of Array
+    end
+  end
+
+  it 'does not fuck up __LINE__ macro' do
+    values_for('__LINE__
+                __LINE__
+
+                def meth
+                  __LINE__
+                end
+                meth
+
+                # comment
+                __LINE__').should == [['1'], ['2'], [], [], ['5'], ['nil'], ['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']]
+    pending "this doesn't work because the return detecting code is a very conservative regexp" do
+      values_for("-> { return 1 }.call"        ).should == [['1']]
+    end
+  end
+
+  it 'does not affect its environment' do
+    invoke 'def Object.abc() end'
+    Object.should_not respond_to :abc
+  end
+
+  it 'captures the standard output and error' do
+    result = invoke "2.times { puts 'a', 'b' }
+                     STDOUT.puts 'c'
+                     $stdout.puts 'd'
+                     STDERR.puts '1', '2'
+                     $stderr.puts '3'
+                     $stdout = $stderr
+                     puts '4'"
+    result.stdout.should == "a\nb\n" "a\nb\n" "c\n" "d\n"
+    result.stderr.should == "1\n2\n" "3\n" "4\n"
+    result.should have_stdout
+    result.should have_stderr
+
+    result = invoke '1+1'
+    result.should_not have_stdout
+    result.should_not have_stderr
+  end
+
+  it 'defaults the filename to temp_dir/program.rb' do
+    result = invoke('print File.expand_path __FILE__')
+    File.basename(result.stdout).should == 'program.rb'
+  end
+
+  it 'can be told to run as a given file (in a given dir/with a given filename)' do
+    filename = File.join proving_grounds_dir, 'mah_file.rb'
+    FileUtils.rm_f filename
+    result   = described_class.new('print File.expand_path __FILE__', filename: filename).call
+    result.stdout.should == filename
+  end
+
+  specify 'cwd is the directory of the file' do
+    filename = File.join proving_grounds_dir, 'mah_file.rb'
+    FileUtils.rm_f filename
+    result   = described_class.new('print File.expand_path __FILE__', filename: filename).call
+    result   = described_class.new('print File.expand_path(Dir.pwd)', filename: filename).call
+    result.stdout.should == proving_grounds_dir
+  end
+
+  it 'does not capture output from __END__ onward' do
+    values_for("1+1\nDATA.read\n__END__\n....").should == [['2'], ['"...."']]
   end
 
-  # it ignores lines that end in comments
-  # something about printing to stdout
-  # something about printing to stderr
   # something about when the whole input is invalid
   # something about multi-line strings
-  # does not fuck up __LINE__ macro
 end

data/spec/syntax_analyzer_spec.rb

@@ -3,8 +3,13 @@ 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['+'].should be_false
     is_valid['1+2'].should be_true
+    is_valid['+'].should be_false
+
+    # 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
   end
 
   it 'knows if the last line is a comment' do
@@ -16,4 +21,110 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     is_comment["a # whatev \n b"].should be_false
     is_comment[""].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
+    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|
+      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|
+      unclosed_string[string].should be_true, "Expected #{string.inspect} to be unclosed"
+    end
+  end
+
+  it 'knows if the code contains an unclosed regexp' do
+    unclosed_regexp = lambda { |code| described_class.unclosed_regexp? code }
+    [%(a),
+     %(/a/),
+     %(/a \n/),
+     %(/a \n a/),
+     %(a \n/ a/),
+     %(/a\\//),
+     %(/\#{//}/),
+     %(%r()),
+     %(%r{}),
+     %(%r<>),
+     %(%r..),
+    ].each do |code|
+      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|
+      unclosed_regexp[code].should be_true, "Expected #{code.inspect} to be unclosed"
+    end
+  end
+
+  # the commented out ones will require actual parsing to solve
+  it "knows if the code contains a return (can't capture a void value)" do
+    will_return = -> code { described_class.will_return? code }
+    will_return["return 1"].should be_true
+    will_return["return 1\n"].should be_true
+    will_return["return 1 if true"].should be_true
+    will_return["return 1 if false"].should be_true
+    will_return["o.return"].should be_false
+    will_return[":return"].should be_false
+    will_return["'return'"].should be_false
+    # will_return["'return\nreturn\nreturn'"].should be_false
+    will_return["def a\nreturn 1\nend"].should be_false
+    will_return["-> {\nreturn 1\n}"].should be_false
+    will_return["Proc.new {\nreturn 1\n}"].should be_false
+    # will_return["return \\\n1"].should be_true
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-03 00:00:00.000000000 Z
+date: 2013-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70251047915180 !ruby/object:Gem::Requirement
+  requirement: &70133565808080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.12.0
   type: :development
   prerelease: false
-  version_requirements: *70251047915180
+  version_requirements: *70133565808080
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70251047914440 !ruby/object:Gem::Requirement
+  requirement: &70133565807280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,18 @@ dependencies:
         version: 1.2.1
   type: :development
   prerelease: false
-  version_requirements: *70251047914440
+  version_requirements: *70133565807280
+- !ruby/object:Gem::Dependency
+  name: ichannel
+  requirement: &70133565806600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.1.1
+  type: :development
+  prerelease: false
+  version_requirements: *70133565806600
 description: Records the results of every line of code in your file (intended to be
   like xmpfilter), inspired by Bret Victor's JavaScript example in his talk "Inventing
   on Principle"
@@ -52,13 +63,21 @@ files:
 - features/step_definitions/steps.rb
 - features/support/env.rb
 - lib/seeing_is_believing.rb
+- lib/seeing_is_believing/error.rb
+- lib/seeing_is_believing/evaluate_by_moving_files.rb
 - lib/seeing_is_believing/example_use.rb
 - lib/seeing_is_believing/expression_list.rb
+- lib/seeing_is_believing/hard_core_ensure.rb
+- lib/seeing_is_believing/has_exception.rb
 - lib/seeing_is_believing/result.rb
 - lib/seeing_is_believing/syntax_analyzer.rb
+- lib/seeing_is_believing/the_matrix.rb
+- lib/seeing_is_believing/tracks_line_numbers_seen.rb
 - lib/seeing_is_believing/version.rb
 - seeing_is_believing.gemspec
+- spec/evaluate_by_moving_files_spec.rb
 - spec/expression_list_spec.rb
+- spec/hard_core_ensure_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/syntax_analyzer_spec.rb
 homepage: https://github.com/JoshCheek/seeing_is_believing
@@ -89,6 +108,8 @@ test_files:
 - features/binary.feature
 - features/step_definitions/steps.rb
 - features/support/env.rb
+- spec/evaluate_by_moving_files_spec.rb
 - spec/expression_list_spec.rb
+- spec/hard_core_ensure_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/syntax_analyzer_spec.rb