seeing_is_believing 0.0.15 → 0.0.16

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    seeing_is_believing (0.0.14)
+    seeing_is_believing (0.0.16)
 
 GEM
   remote: http://rubygems.org/

data/Readme.md

@@ -132,6 +132,7 @@ Known Issues
 * Heredocs aren't recorded. It might actually be possible if the ExpressionList were to get smarter
 * Return statements are dealt with poorly, causing some situations where you could capture and display a value to not capture
 * errors come out really shitty if you're calling them from another program like TextMate, would be better to put a line in that shows where the error is.
+* Add a time limit to auto-kill it if it gets stuck or something (e.g. stack overflow is painful to wait for)
 
 License
 =======

data/features/examples.feature

@@ -255,3 +255,10 @@ Feature: Running the binary successfully
     And the exit status is 0
     And stdout is "1 + 1  # => 2"
 
+  Scenario: Regression: A program containing a single comment
+    Given I have the stdin content "# single comment"
+    When I run "seeing_is_believing"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is "# single comment"
+

data/features/flags.feature

@@ -231,6 +231,12 @@ Feature: Using flags
     And the exit status is 0
     And stdout is '1+'
 
+  Scenario: --version
+    When I run 'seeing_is_believing --version'
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is '{{SeeingIsBelieving::VERSION}}'
+
   Scenario: --help
     When I run "seeing_is_believing --help"
     Then stderr is empty

data/features/step_definitions/steps.rb

@@ -1,11 +1,11 @@
-Given('the file "$filename" "$body"')        { |filename, body|       CommandLineHelpers.write_file filename, body }
-Given('the file "$filename":')               { |filename, body|       CommandLineHelpers.write_file filename, body }
-Given('I have the stdin content "$content"') { |content|              @stdin_data = content }
-Given('I have the stdin content:')           { |content|              @stdin_data = content }
+Given('the file "$filename" "$body"')        { |filename, body|       CommandLineHelpers.write_file filename, eval_curlies(body) }
+Given('the file "$filename":')               { |filename, body|       CommandLineHelpers.write_file filename, eval_curlies(body) }
+Given('I have the stdin content "$content"') { |content|              @stdin_data = eval_curlies(content) }
+Given('I have the stdin content:')           { |content|              @stdin_data = eval_curlies(content) }
 When('I run "$command"')                     { |command|              @last_executed = CommandLineHelpers.execute command, @stdin_data }
 When("I run '$command'")                     { |command|              @last_executed = CommandLineHelpers.execute command, @stdin_data }
-Then(/^(stderr|stdout) is:$/)                { |stream_name, output|  @last_executed.send(stream_name).chomp.should == output }
-Then(/^(stderr|stdout) is ["'](.*?)["']$/)   { |stream_name, output|  @last_executed.send(stream_name).chomp.should == output }
+Then(/^(stderr|stdout) is:$/)                { |stream_name, output|  @last_executed.send(stream_name).chomp.should == eval_curlies(output) }
+Then(/^(stderr|stdout) is ["'](.*?)["']$/)   { |stream_name, output|  @last_executed.send(stream_name).chomp.should == eval_curlies(output) }
 Then(/^(stderr|stdout) is empty$/)           { |stream_name|          @last_executed.send(stream_name).should == '' }
-Then(/^(stderr|stdout) includes "([^"]*)"$/) { |stream_name, content| @last_executed.send(stream_name).should include content }
+Then(/^(stderr|stdout) includes "([^"]*)"$/) { |stream_name, content| @last_executed.send(stream_name).should include eval_curlies(content) }
 Then('the exit status is $status')           { |status|               @last_executed.exitstatus.to_s.should == status }

data/features/support/env.rb

@@ -1,5 +1,6 @@
 require 'fileutils'
 require 'open3'
+require_relative '../../lib/seeing_is_believing/version'
 
 
 module CommandLineHelpers

data/lib/seeing_is_believing.rb

@@ -3,6 +3,7 @@ require 'tmpdir'
 
 require 'seeing_is_believing/queue'
 require 'seeing_is_believing/result'
+require 'seeing_is_believing/version'
 require 'seeing_is_believing/expression_list'
 require 'seeing_is_believing/evaluate_by_moving_files'
 
@@ -35,13 +36,13 @@ class SeeingIsBelieving
       leading_comments = ''
 
       # extract leading comments (e.g. encoding) so they don't get wrapped in begin/rescue/end
-      while next_line_queue.peek =~ /^\s*#/
+      while SyntaxAnalyzer.line_is_comment?(next_line_queue.peek)
         leading_comments << next_line_queue.dequeue << "\n"
         @line_number += 1
       end
 
       # extract leading =begin/=end so they don't get wrapped in begin/rescue/end
-      while next_line_queue.peek == '=begin'
+      while SyntaxAnalyzer.begins_multiline_comment?(next_line_queue.peek)
         lines = next_line_queue.dequeue << "\n"
         @line_number += 1
         until SyntaxAnalyzer.begin_and_end_comments_are_complete? lines
@@ -53,7 +54,7 @@ class SeeingIsBelieving
 
       # extract program body
       body = ''
-      until next_line_queue.peek.nil? || data_segment?
+      until next_line_queue.empty? || data_segment?
         expression, expression_size = expression_list.call
         body << expression
         track_line_number @line_number
@@ -128,7 +129,7 @@ class SeeingIsBelieving
   end
 
   def data_segment?
-    next_line_queue.peek == '__END__'
+    SyntaxAnalyzer.begins_data_segment?(next_line_queue.peek)
   end
 
   def next_line_queue
@@ -140,9 +141,9 @@ class SeeingIsBelieving
   end
 
   def do_not_record?(code)
-    code =~ BLANK_REGEX                     ||
-      SyntaxAnalyzer.ends_in_comment?(code) ||
-      SyntaxAnalyzer.will_return?(code)     ||
+    code =~ BLANK_REGEX                           ||
+      SyntaxAnalyzer.ends_in_comment?(code)       ||
+      SyntaxAnalyzer.void_value_expression?(code) ||
       SyntaxAnalyzer.here_doc?(code)
   end
 end

data/lib/seeing_is_believing/binary.rb

@@ -17,6 +17,7 @@ class SeeingIsBelieving
     def call
       @exitstatus ||= if    flags_have_errors?          then print_errors          ; 1
                       elsif should_print_help?          then print_help            ; 0
+                      elsif should_print_version?       then print_version         ; 0
                       elsif has_filename? && file_dne?  then print_file_dne        ; 1
                       elsif should_clean?               then print_cleaned_program ; 0
                       elsif invalid_syntax?             then print_syntax_error    ; 1
@@ -70,6 +71,14 @@ class SeeingIsBelieving
       stdout.puts flags[:help]
     end
 
+    def should_print_version?
+      flags[:version]
+    end
+
+    def print_version
+      stdout.puts SeeingIsBelieving::VERSION
+    end
+
     def file_is_on_stdin?
       flags[:filename].nil? && flags[:program].nil?
     end

data/lib/seeing_is_believing/binary/arg_parser.rb

@@ -16,8 +16,9 @@ class SeeingIsBelieving
         @result ||= begin
           until args.empty?
             case (arg = args.shift)
-            when '-h', '--help'          then options[:help] = self.class.help_screen
-            when '-c', '--clean'         then options[:clean] = true
+            when '-h', '--help'          then options[:help]    = self.class.help_screen
+            when '-v', '--version'       then options[:version] = true
+            when '-c', '--clean'         then options[:clean]   = true
             when '-l', '--start-line'    then extract_positive_int_for :start_line,    arg
             when '-L', '--end-line'      then extract_positive_int_for :end_line,      arg
             when '-d', '--line-length'   then extract_positive_int_for :line_length,   arg
@@ -57,6 +58,7 @@ class SeeingIsBelieving
 
       def options
         @options ||= {
+          version:       false,
           clean:         false,
           program:       nil,
           filename:      nil,
@@ -104,6 +106,7 @@ Usage: #{$0} [options] [filename]
   -K, --encoding encoding # sets file encoding, equivalent to Ruby's -Kx (see `man ruby` for valid values)
   -a, --as filename       # run the program as if it was the specified filename
   -c, --clean             # remove annotations from previous runs of seeing_is_believing
+  -v, --version           # print the version (#{VERSION})
   -h, --help              # this help screen
 HELP_SCREEN
     end

data/lib/seeing_is_believing/binary/print_results_next_to_lines.rb

@@ -78,18 +78,19 @@ class SeeingIsBelieving
       end
 
       def start_of_data_segment?(line)
-        line.chomp == '__END__'
+        SyntaxAnalyzer.begins_data_segment?(line.chomp)
       end
 
-      # max line length of the lines to output (exempting coments) + 2 spaces for padding
+      # max line length of the lines to output (exempting comments) + 2 spaces for padding
       def max_source_line_length
         @max_source_line_length ||= 2 + body.each_line
                                             .map(&:chomp)
                                             .select.with_index(1) { |line, index| start_line <= index && index <= end_line }
                                             .take_while { |line| not start_of_data_segment? line }
-                                            .select { |line| not (line == "=begin") .. (line == "=end") }
+                                            .select { |line| not SyntaxAnalyzer.begins_multiline_comment?(line) .. SyntaxAnalyzer.ends_multiline_comment?(line ) }
                                             .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
                                             .map(&:length)
+                                            .concat([0])
                                             .max
       end
 

data/lib/seeing_is_believing/expression_list.rb

@@ -49,7 +49,7 @@ class SeeingIsBelieving
       # method invocations can be put on the next line, and begin with a dot.
       # I think that's the only case we need to worry about.
       # e.g: `3\n.times { |i| p i }`
-      peek_next_line.call && peek_next_line.call =~ /^\s*\./
+      peek_next_line.call && SyntaxAnalyzer.next_line_modifies_current?(peek_next_line.call)
     end
 
     def inspected_expressions(expressions)

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -51,6 +51,14 @@ class SeeingIsBelieving
       parsed(code).valid_ruby? && begin_and_end_comments_are_complete?(code)
     end
 
+    def self.begins_multiline_comment?(line)
+      line == '=begin'
+    end
+
+    def self.ends_multiline_comment?(line)
+      line == '=end'
+    end
+
     def self.begin_and_end_comments_are_complete?(code)
       code.scan(/^=(?:begin|end)$/)
           .each_slice(2)
@@ -65,6 +73,16 @@ class SeeingIsBelieving
       @has_error || unclosed_string? || unclosed_regexp?
     end
 
+    # MISC
+
+    def self.begins_data_segment?(line)
+      line == '__END__'
+    end
+
+    def self.next_line_modifies_current?(line)
+      line =~ /^\s*\./
+    end
+
     # STRINGS
 
     def self.unclosed_string?(code)
@@ -115,6 +133,10 @@ class SeeingIsBelieving
 
     # COMMENTS
 
+    def self.line_is_comment?(line)
+      line =~ /^\s*#/
+    end
+
     def self.ends_in_comment?(code)
       code =~ /^=end\Z/ || parsed(code.lines.to_a.last.to_s).has_comment?
     end
@@ -136,8 +158,8 @@ class SeeingIsBelieving
 
     # this is conspicuosuly inferior, but I can't figure out how to actually parse it
     # see: http://www.ruby-forum.com/topic/4409633
-    def self.will_return?(code)
-      /(^|\s)return.*?\n?\z/ =~ code
+    def self.void_value_expression?(code)
+      /(^|\s)(?:return|next|redo|retry|break).*?\n?\z/ =~ code
     end
 
     # HERE DOCS

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.15'
+  VERSION = '0.0.16'
 end

data/spec/arg_parser_spec.rb

@@ -248,5 +248,16 @@ describe SeeingIsBelieving::Binary::ArgParser do
       parse(%w[--clean])[:clean].should == true
     end
   end
+
+  describe ':version' do
+    it 'defaults to false' do
+      parse([])[:version].should == false
+    end
+
+    it 'can be set with -v and --version' do
+      parse(%w[-v])[:version].should == true
+      parse(%w[--version])[:version].should == true
+    end
+  end
 end
 

data/spec/seeing_is_believing_spec.rb

@@ -172,6 +172,41 @@ describe SeeingIsBelieving do
     # values_for("-> { return 1 }.call"        ).should == [['1']]
   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']]
+  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']]
+      def meth
+        n = 0
+        for i in 0...3
+          n += 1
+          redo if n == 2
+        end
+      end
+      meth
+    DOC
+  end
+
+  it 'does not try to record the keyword retry' do
+    values_for(<<-DOC).should == [[], [], [], ['nil']]
+      def meth
+      rescue
+        retry
+      end
+    DOC
+  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
+  end
+
   it 'does not affect its environment' do
     invoke 'def Object.abc() end'
     Object.should_not respond_to :abc

data/spec/syntax_analyzer_spec.rb

@@ -62,6 +62,23 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     is_unclosed_comment[" =begin"].should be_false
   end
 
+  it 'knows if the line begins a multiline comment' do
+    described_class.begins_multiline_comment?('=begin').should be_true
+    described_class.begins_multiline_comment?('=begins').should be_false
+  end
+
+  it 'knows if the line ends a multiline comment' do
+    described_class.ends_multiline_comment?('=end').should be_true
+    described_class.ends_multiline_comment?('=ends').should be_false
+  end
+
+  it 'knows when the line is a comment' do
+    described_class.line_is_comment?('# abc').should be_true
+    described_class.line_is_comment?(' # abc').should be_true
+    described_class.line_is_comment?('a # abc').should be_false
+    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
@@ -154,22 +171,44 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     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["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
-    pending "this doesn't work because the return detecting code is an insufficient regexp" do
-      will_return["'return\nreturn\nreturn'"].should be_false
-      will_return["return \\\n1"].should be_true
+  shared_examples_for 'void_value_expression?' do |keyword|
+    it "returns true when the expression ends in #{keyword}" do
+      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?("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?("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
+    end
+
+    it "doesn't work because the return and next keyword evaluators are insufficient regexps" do
+      pending "doesn't pass yet (and prob never will >.<)" do
+        described_class.send(evalutor, "'#{keyword}\n#{keyword}\n#{keyword}'").should be_false
+        described_class.send(evalutor, "#{keyword} \\\n1").should be_true
+      end
     end
   end
+
+  it_should_behave_like 'void_value_expression?', 'return'
+  it_should_behave_like 'void_value_expression?', 'next'
+  it_should_behave_like 'void_value_expression?', 'redo'
+  it_should_behave_like 'void_value_expression?', 'retry'
+  it_should_behave_like 'void_value_expression?', 'break'
+
+  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

metadata

@@ -2,14 +2,14 @@
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-02 00:00:00.000000000 Z
+date: 2013-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement