seeing_is_believing 0.0.23 → 0.0.24

data/Readme.md

@@ -92,6 +92,12 @@ See [sublime-text-2-seeing-is-believing](https://github.com/JoshCheek/sublime-te
 TextMate Integration
 ====================
 
+Note: This assumes you've already set up Ruby to work with TextMate.
+If not, you'll need to start there. [Here](https://rvm.io/integration/textmate/)
+are instructions for RVM (I recommend the wrapper approach).
+[Here](http://uberfork.com/post/12280974742/integrate-rbenv-with-textmate)
+are instructions for rbenv.
+
 Go to the bundle editor, create this new command in the Ruby bundle:
 
 ```shell
@@ -140,8 +146,8 @@ Known Issues
 Todo
 ====
 
+* Move as much of the SyntaxAnalyzer as possible over to Parser and ditch Ripper altogether
 * Refactor ExpressionList/SeeingIsBelieving to store lines in an array instead of as a string, so everyone doesn't magically need to know when to chomp
-* Make friends who actually know how to parse Ruby syntax (omg, teach me Ripper, pls, it will make this lib so much better, you have no idea O.o)
 
 License
 =======

data/features/examples.feature

@@ -235,7 +235,7 @@ Feature: Running the binary successfully
     """
 
   Scenario: Reading from stdin
-    Given I have the stdin content "hi!"
+    Given the stdin content "hi!"
     And the file "reads_from_stdin.rb":
     """
     puts "You said: #{gets}"
@@ -251,7 +251,7 @@ Feature: Running the binary successfully
     """
 
   Scenario: Passing the file on stdin
-    Given I have the stdin content "1 + 1"
+    Given the stdin content "1 + 1"
     When I run "seeing_is_believing"
     Then stderr is empty
     And the exit status is 0

data/features/flags.feature

@@ -223,7 +223,7 @@ Feature: Using flags
 
   Scenario: --as and stdin
     Given the file "example.rb" "1+1"
-    Given I have the stdin content:
+    Given the stdin content:
     """
     1+1
     __FILE__
@@ -397,3 +397,43 @@ Feature: Using flags
     1 + 1  # => 2
     1 + 1 + 1  # => 3
     """
+
+  Scenario: --inherit-exit-status
+    Given the file "exit_status.rb" "exit 123"
+    When I run "seeing_is_believing exit_status.rb"
+    Then the exit status is 1
+    When I run "seeing_is_believing --inherit-exit-status exit_status.rb"
+    Then the exit status is 123
+
+  # Show that Ruby exceptions exit with 1, and --inherit-exit-status does as well
+  Scenario: --inherit-exit-status
+    Given the file "exception_exit_status.rb" "raise Exception"
+    When I run "ruby exception_exit_status.rb"
+    Then the exit status is 1
+    When I run "seeing_is_believing --inherit-exit-status exception_exit_status.rb"
+    Then the exit status is 1
+
+  Scenario: --inherit-exit-status in an at_exit block
+    Given the file "exit_status_in_at_exit_block.rb" "at_exit { exit 10 }"
+    When I run "seeing_is_believing exit_status_in_at_exit_block.rb"
+    Then the exit status is 0
+    When I run "seeing_is_believing --inherit-exit-status exit_status_in_at_exit_block.rb"
+    Then the exit status is 10
+
+  @wip
+  Scenario: --xmpfilter-style
+    Given the file "magic_comments.rb":
+    """
+    1# =>
+    1    # =>
+    1
+    """
+    When I run "seeing_is_believing --xmpfilter-style magic_comments.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    1# => 1
+    1    # => 1
+    1
+    """

data/features/regression.feature

@@ -4,7 +4,7 @@ Feature:
   I want to have tests on those bugs that I found and could not have predicted
 
   Scenario: A program containing a single comment
-    Given I have the stdin content "# single comment"
+    Given the stdin content "# single comment"
     When I run "seeing_is_believing"
     Then stderr is empty
     And the exit status is 0
@@ -23,7 +23,7 @@ Feature:
     a  # ~> NameError: undefined local variable or method `a' for main:Object
     """
 
-  Scenario:
+  Scenario: Errors being raised in the evaluated code that don't exist in the evaluating code
     Given the file "raising_custom_errors.rb":
     """
     MyError = Class.new StandardError
@@ -36,3 +36,27 @@ Feature:
     When I run "seeing_is_believing raising_custom_errors.rb"
     Then stderr is empty
     And the exit status is 1
+
+  Scenario: statements that inherit void value expressions
+    Given the file "statements_that_inherit_void_value_expressions.rb":
+    """
+    def m
+      if true
+        return 1
+      end
+    end
+    m
+    """
+    When I run "seeing_is_believing statements_that_inherit_void_value_expressions.rb"
+    Then stderr is empty
+    And the exit status is 0
+    Then stdout is:
+    """
+    def m
+      if true
+        return 1
+      end
+    end           # => nil
+    m             # => 1
+    """
+

data/features/support/env.rb

@@ -1,78 +1,8 @@
-require 'fileutils'
-require 'open3'
 require_relative '../../lib/seeing_is_believing/version'
 
-
-module CommandLineHelpers
-  Invocation = Struct.new :stdout, :stderr, :status do
-    def exitstatus
-      status.exitstatus
-    end
-  end
-
-  extend self
-
-  def write_file(filename, body)
-    in_proving_grounds do
-      FileUtils.mkdir_p File.dirname filename
-      File.open(filename, 'w') { |file| file.write body }
-    end
-  end
-
-  def execute(command, stdin_data=nil)
-    stdin_data ||= ''
-    in_proving_grounds do
-      with_bin_in_path do
-        Invocation.new *Open3.capture3(command, stdin_data: stdin_data)
-      end
-    end
-  end
-
-  def in_proving_grounds(&block)
-    Dir.chdir proving_grounds_dir, &block
-  end
-
-  def proving_grounds_dir
-    File.join root_dir, 'proving_grounds'
-  end
-
-  def root_dir
-    @root_dir ||= begin
-      dir = File.expand_path Dir.pwd
-      dir = File.dirname dir until Dir["#{dir}/*"].map { |fn| File.basename fn }.include?('lib')
-      dir
-    end
-  end
-
-  def make_proving_grounds
-    FileUtils.mkdir_p proving_grounds_dir
-  end
-
-  def bin_dir
-    File.join root_dir, "bin"
-  end
-
-  def path_to(filename)
-    in_proving_grounds { File.join proving_grounds_dir, filename }
-  end
-
-  # workaround for Ruby 2.0 bug where passing the new path as the first arg wasn't working
-  # bug report submitted here: http://bugs.ruby-lang.org/issues/8004
-  def with_bin_in_path
-    original_path = ENV['PATH']
-    ENV['PATH'] = "#{bin_dir}:#{ENV['PATH']}"
-    yield
-  ensure
-    ENV['PATH'] = original_path
-  end
-end
-
-CommandLineHelpers.make_proving_grounds
-
-module GeneralHelpers
-  def eval_curlies(string)
-    string.gsub(/{{(.*?)}}/) { eval $1 }
-  end
+require 'haiti'
+Haiti.configure do |config|
+  config.proving_grounds_dir = File.expand_path '../../../proving_grounds', __FILE__
+  config.bin_dir             = File.expand_path '../../../bin',             __FILE__
 end
 
-World GeneralHelpers

data/lib/seeing_is_believing.rb

@@ -108,6 +108,8 @@ class SeeingIsBelieving
     "rescue Exception;"\
       "line_number = $!.backtrace.grep(/\#{__FILE__}/).first[/:\\d+/][1..-1].to_i;"\
       "$seeing_is_believing_current_result.record_exception line_number, $!;"\
+      "$seeing_is_believing_current_result.exitstatus = 1;"\
+      "$seeing_is_believing_current_result.exitstatus = $!.status if $!.kind_of? SystemExit;"\
     "end"
   end
 

data/lib/seeing_is_believing/binary.rb

@@ -28,16 +28,25 @@ class SeeingIsBelieving
                       elsif invalid_syntax?             then print_syntax_error     ; NONDISPLAYABLE_ERROR_STATUS
                       elsif program_timedout?           then print_timeout_error    ; NONDISPLAYABLE_ERROR_STATUS
                       elsif something_blew_up?          then print_unexpected_error ; NONDISPLAYABLE_ERROR_STATUS
-                      else                                   print_program          ; (results.has_exception? ?
-                                                                                         DISPLAYABLE_ERROR_STATUS :
-                                                                                         SUCCESS_STATUS)
+                      else                                   print_program          ; program_exit_status
                       end
     end
 
+    # uhm, this is dumb
     alias exitstatus call
 
     private
 
+    def program_exit_status
+      if flags[:inherit_exit_status]
+        results.exitstatus
+      elsif results.has_exception?
+        DISPLAYABLE_ERROR_STATUS
+      else
+        SUCCESS_STATUS
+      end
+    end
+
     def has_filename?
       flags[:filename]
     end

data/lib/seeing_is_believing/binary/arg_parser.rb

@@ -21,22 +21,24 @@ class SeeingIsBelieving
         @result ||= begin
           until args.empty?
             case (arg = args.shift)
-            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
-            when '-D', '--result-length'      then extract_positive_int_for :result_length, arg
-            when '-t', '--timeout'            then extract_non_negative_float_for :timeout, arg
-            when '-r', '--require'            then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:require]            << filename }
-            when '-I', '--load-path'          then next_arg("#{arg} expected a directory as the following argument but did not see one") { |dir|      options[:load_path]          << dir }
-            when '-e', '--program'            then next_arg("#{arg} expected a program as the following argument but did not see one")   { |program|  options[:program]            = program }
-            when '-a', '--as'                 then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:as]                 = filename }
-            when '-s', '--alignment-strategy' then extract_alignment_strategy
-            when /\A-K(.+)/                   then options[:encoding] = $1
-            when '-K', '--encoding'           then next_arg("#{arg} expects an encoding, see `man ruby` for possibile values") { |encoding| options[:encoding] = encoding }
-            when /^-/                         then options[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
+            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 '-x', '--xmpfilter-style'     then options[:xmpfilter_style]     = true
+            when '-i', '--inherit-exit-status' then options[:inherit_exit_status] = 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
+            when '-D', '--result-length'       then extract_positive_int_for :result_length, arg
+            when '-t', '--timeout'             then extract_non_negative_float_for :timeout, arg
+            when '-r', '--require'             then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:require]            << filename }
+            when '-I', '--load-path'           then next_arg("#{arg} expected a directory as the following argument but did not see one") { |dir|      options[:load_path]          << dir }
+            when '-e', '--program'             then next_arg("#{arg} expected a program as the following argument but did not see one")   { |program|  options[:program]            = program }
+            when '-a', '--as'                  then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:as]                 = filename }
+            when '-s', '--alignment-strategy'  then extract_alignment_strategy
+            when /\A-K(.+)/                    then options[:encoding] = $1
+            when '-K', '--encoding'            then next_arg("#{arg} expects an encoding, see `man ruby` for possibile values") { |encoding| options[:encoding] = encoding }
+            when /^-/                          then options[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
             else
               filenames << arg
               options[:filename] = arg
@@ -145,6 +147,7 @@ Usage: seeing_is_believing [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
+  -i, --inherit-exit-status # exit with the exit status of the program being eval
   -v, --version             # print the version (#{VERSION})
   -h, --help                # this help screen
 HELP_SCREEN

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -13,6 +13,7 @@
 
 require 'yaml'
 require 'open3'
+require 'timeout'
 require 'stringio'
 require 'fileutils'
 require 'seeing_is_believing/error'
@@ -43,8 +44,7 @@ class SeeingIsBelieving
           write_program_to_file
           begin
             evaluate_file
-            fail unless exitstatus.success?
-            deserialize_result
+            deserialize_result.tap { |result| fail if result.bug_in_sib? }
           # Okay, really, I should wrap this in another exception and raise it on up,
           # but for now, I'm feeling a little lazy and am not going to do it
           rescue Exception
@@ -57,10 +57,6 @@ class SeeingIsBelieving
         }
     end
 
-    def error_implies_bug_in_sib?(error)
-      not error.kind_of? Timeout::Error
-    end
-
     def file_directory
       File.dirname filename
     end
@@ -73,6 +69,10 @@ class SeeingIsBelieving
 
     attr_accessor :stdout, :stderr, :exitstatus
 
+    def error_implies_bug_in_sib?(error)
+      not error.kind_of? Timeout::Error
+    end
+
     def we_will_not_overwrite_existing_tempfile!
       raise TempFileAlreadyExists.new(filename, temp_filename) if File.exist? temp_filename
     end

data/lib/seeing_is_believing/result.rb

@@ -8,7 +8,9 @@ class SeeingIsBelieving
     include TracksLineNumbersSeen
     include Enumerable
 
-    attr_accessor :stdout, :stderr
+    attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib
+
+    alias bug_in_sib? bug_in_sib
 
     def has_stdout?
       stdout && !stdout.empty?

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -1,4 +1,5 @@
 require 'ripper'
+require 'parser/current'
 
 class SeeingIsBelieving
   class SyntaxAnalyzer < Ripper::SexpBuilder
@@ -156,10 +157,22 @@ class SeeingIsBelieving
 
     # RETURNS
 
-    # 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.void_value_expression?(code)
-      /(^|\s)(?:return|next|redo|retry|break)([^\w\n]|\n?\z).*?\n?\z/ =~ code
+    def self.void_value_expression?(code_or_ast)
+      ast = code_or_ast
+      ast = Parser::CurrentRuby.parse(code_or_ast) if code_or_ast.kind_of? String
+
+      case ast && ast.type
+      when :begin, :resbody
+        void_value_expression?(ast.children[-1])
+      when :rescue, :ensure
+        ast.children.any? { |child| void_value_expression? child }
+      when :if
+        void_value_expression?(ast.children[1]) || void_value_expression?(ast.children[2])
+      when :return, :next, :redo, :retry, :break
+        true
+      else
+        false
+      end
     end
 
     # HERE DOCS

data/lib/seeing_is_believing/the_matrix.rb

@@ -15,5 +15,10 @@ at_exit do
   $seeing_is_believing_current_result.stdout = fake_stdout.string
   $seeing_is_believing_current_result.stderr = fake_stderr.string
 
+  $seeing_is_believing_current_result.exitstatus ||= 0
+  $seeing_is_believing_current_result.exitstatus   = 1         if $!
+  $seeing_is_believing_current_result.exitstatus   = $!.status if $!.kind_of? SystemExit
+  $seeing_is_believing_current_result.bug_in_sib   = $! && ! $!.kind_of?(SystemExit)
+
   real_stdout.write YAML.dump $seeing_is_believing_current_result
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.23'
+  VERSION = '0.0.24'
 end

data/seeing_is_believing.gemspec

@@ -19,6 +19,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.add_dependency             "parser",   "~> 1.4"
+
+  s.add_development_dependency "haiti",    "~> 0.0.3"
   s.add_development_dependency "rake",     "~> 10.0.3"
   s.add_development_dependency "rspec",    "~> 2.12.0"
   s.add_development_dependency "cucumber", "~> 1.2.1"

data/spec/arg_parser_spec.rb

@@ -57,8 +57,8 @@ describe SeeingIsBelieving::Binary::ArgParser do
 
   specify 'unknown options set an error' do
     parse(['--xyz']).should have_error 'Unknown option: "--xyz"'
-    parse(['-x']).should have_error 'Unknown option: "-x"'
-    parse(['-x', 'b']).should have_error 'Unknown option: "-x"'
+    parse(['-y']).should have_error 'Unknown option: "-y"'
+    parse(['-y', 'b']).should have_error 'Unknown option: "-y"'
   end
 
   example 'example: multiple args' do
@@ -311,5 +311,27 @@ describe SeeingIsBelieving::Binary::ArgParser do
       parse(['-s'        ]).should     have_error /alignment-strategy/
     end
   end
+
+  describe ':inherit_exit_status' do
+    it 'defaults to false' do
+      parse([])[:inherit_exit_status].should be_false
+    end
+
+    it 'can be set with --inherit-exit-status or -i' do
+      parse(['--inherit-exit-status'])[:inherit_exit_status].should be_true
+      parse(['-i'])[:inherit_exit_status].should be_true
+    end
+  end
+
+  describe ':xmpfilter_style' do
+    it 'defaults to false' do
+      parse([])[:xmpfilter_style].should be_false
+    end
+
+    it 'can be set with --xmpfilter-style or -x' do
+      parse(['--xmpfilter-style'])[:xmpfilter_style].should be_true
+      parse(['-x'])[:xmpfilter_style].should be_true
+    end
+  end
 end
 

data/spec/seeing_is_believing_spec.rb

@@ -284,6 +284,12 @@ describe SeeingIsBelieving do
     expect { invoke "sleep 0.2", timeout: 0.1 }.to raise_error Timeout::Error
   end
 
+  it 'records the exit status' do
+    invoke('raise "omg"').exitstatus.should == 1
+    invoke('exit 123').exitstatus.should == 123
+    invoke('at_exit { exit 121 }').exitstatus.should == 121
+  end
+
   it 'can record the middle of a chain of calls', not_implemented: true  do
     values_for("[*1..5]
                   .select(&:even?)

data/spec/syntax_analyzer_spec.rb

@@ -171,37 +171,175 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     end
   end
 
-  shared_examples_for 'void_value_expression?' do |keyword|
-    it "`#{keyword}` returns true when the expression ends in #{keyword}", t:true do
+  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}(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?("#{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} 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}_something").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 "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
+    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 '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_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

metadata

@@ -2,15 +2,47 @@
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.0.23
+  version: 0.0.24
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-11 00:00:00.000000000 Z
+date: 2013-06-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    none: false
+  name: parser
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+    none: false
+  name: haiti
+  type: :development
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+    none: false
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -95,7 +127,6 @@ files:
 - features/examples.feature
 - features/flags.feature
 - features/regression.feature
-- features/step_definitions/steps.rb
 - features/support/env.rb
 - lib/seeing_is_believing.rb
 - lib/seeing_is_believing/binary.rb
@@ -158,7 +189,6 @@ test_files:
 - features/examples.feature
 - features/flags.feature
 - features/regression.feature
-- features/step_definitions/steps.rb
 - features/support/env.rb
 - spec/arg_parser_spec.rb
 - spec/evaluate_by_moving_files_spec.rb

data/features/step_definitions/steps.rb

@@ -1,12 +0,0 @@
-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 == 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) is not empty$/)       { |stream_name|          @last_executed.send(stream_name).chomp.should_not be_empty }
-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 }