seeing_is_believing 2.0.0.beta2 → 2.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a743322b1fb2c802a3c3e76876a799b4dcaaeae9
-  data.tar.gz: d6e24494bf3967f3958e73aa7df22a09c960c089
+  metadata.gz: a95d8680853f82d8aee58a8ba40d16a113662f20
+  data.tar.gz: 6e9fecb99be2adf05d75bb42d2c8a37de1ff1c7b
 SHA512:
-  metadata.gz: 49aa7ad618d82e0fad1902a7fe43489ea606df56ae932bb6e4802a70e70f4d1e28a871332d65bc42137954f4857eed385ee6621231633b5a51718e90e6d600bd
-  data.tar.gz: 11fdde4edaae47edf12ed0f2e19c8b3ec4c4e0a43125860dcb74b5a8193a8c497b5e5e3822425127cff5aadf7e0230632eeb8eb29f5db9da5caba443d80c4843
+  metadata.gz: 291941c2ca6975b233ecfe9f8428f40638331839ec29591d955333d49a3bf975ed0478ca67059e41a7583ddd8b18e9140a9f632b8242665d8fdfed939e8bf319
+  data.tar.gz: 138ae24e20da808a5ea5eb31bcc9ab4eede0163054a130478f79f1e00842b5c56b073f104c98c952f77e0b5698ca6e626691e4818137db136811eaa4e64fff30

data/Readme.md

@@ -98,26 +98,59 @@ 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:
+Go to the bundle editor, create a new command (I put it in the Ruby bundle)
+You can name it what you want, I went with "seeing is believing annotate all lines"
 
 ```shell
+#!/bin/bash
+
+# set result length because TextMate has difficulty displaying long lines
+default_options=""
+default_options="$default_options -Ku"
+default_options="$default_options --result-length 200"
+default_options="$default_options --alignment-strategy chunk"
+default_options="$default_options --timeout 12"
+
 if [ -z "$TM_FILEPATH" ]; then
-  "${TM_RUBY}" -S seeing_is_believing -Ku --result-length 200 --alignment-strategy chunk --timeout 12
+  "${TM_RUBY}" -S seeing_is_believing $default_options
 else
-  "${TM_RUBY}" -S seeing_is_believing -Ku --result-length 200 --as "$TM_FILEPATH" --alignment-strategy chunk --timeout 12
+  "${TM_RUBY}" -S seeing_is_believing $default_options --as "$TM_FILEPATH"
 fi
 ```
 
-It should look like this:
+You can also make one for annotating only the lines you have marked.
+I named it "seeing is believing annotate marked lines"
+
+```shell
+#!/bin/bash
+
+# set result length because TextMate has difficulty displaying long lines
+default_options=""
+default_options="$default_options --xmpfilter-style"
+default_options="$default_options -Ku"
+default_options="$default_options --result-length 200"
+default_options="$default_options --alignment-strategy chunk"
+default_options="$default_options --timeout 12"
 
-![textmate-integration][textmate-integration]
+if [ -z "$TM_FILEPATH" ]; then
+  "${TM_RUBY}" -S seeing_is_believing $default_options
+else
+  "${TM_RUBY}" -S seeing_is_believing $default_options --as "$TM_FILEPATH"
+fi
+```
 
-I also recommend a second command for cleaning the output:
+And you'll probably want one to clean out the outpt
 
 ```shell
+#!/bin/bash
 "${TM_RUBY}" -S seeing_is_believing -Ku --clean
 ```
 
+You can bind them to whatever keys you want, but I'll recomend (for consistency with what I chose for the Sublime bundle)
+* annotate all lines -> Command Option b
+* annotate marked lines -> Command Option n
+* remove annotations -> Command Option v
+
 Emacs Integration
 =================
 
@@ -146,21 +179,23 @@ Known Issues
 Todo
 ====
 
-* Add examples of invocations to the help screen
-* Add xmpfilter option to sublime text
-* Update TextMate examples to use same keys as sublime, add xmpfilter option on cmd+opt+N
-* How about if begin/rescue/end was able to record the result on the rescue section
-* Check how begin/rescue/end with multiple rescue blocks works
-* What about recording the result of a line inside of a string interpolation, e.g. "a#{\n1\n}b" could record line 2 is 1 and line 3 is "a\n1\nb"
-* Be able to clean an invalid file (used to be able to do this, but parser can't identify comments in an invalid file the way that I'm currently using it, cuke is still there, marked as @not-implemented)
-* Add a flag to allow you to just get the results so that it can be easily used without a Ruby runtime
+* Sublime: Merge xmpfilter option into main after 2.0 release
+* Make TextMate 1 and 2 bundles
 * Go through each cuke and spec, implementing however many not-implemented ones that we can
-* Check %w and all the others
-* Add a --shebang flag
 * Make sure the examples in this readme all still make sense (mountain berry fields?)
-* uhm, can we wrap the parser setup code in one place? `ack Parser::Source::Buffer`
-* Make the fucking debugger not lazy
 * Go through Peter's email about how to make the use of Parser better
+* Make a new video
+* Add versions to the debugging output
+* Shorten the debugging output
+
+Shit that will probably never get done (or if it does, won't be until after 2.0)
+================================================================================
+
+* How about if begin/rescue/end was able to record the result on the rescue section
+* What about recording the result of a line inside of a string interpolation, e.g. "a#{\n1\n}b" could record line 2 is 1 and line 3 is "a\n1\nb"
+* Add a flag to allow you to just get the results so that it can be easily used without a Ruby runtime (difficult in that its unclear how to separate line output from stdout, stderr, exit status, exceptions, etc. Maybe just serialize the result as JSON?)
+* Be able to clean an invalid file (used to be able to do this, but parser can't identify comments in an invalid file the way that I'm currently using it, cuke is still there, marked as @not-implemented)
+* If given a file with a unicode character, but not set unicode, inform the user
 
 License
 =======

data/features/flags.feature

@@ -507,3 +507,21 @@ Feature: Using flags
     1# 123
     2  # => 2
     """
+
+  Scenario: --shebang
+    Given the file "fake_ruby":
+    """
+    #!/usr/bin/env ruby
+    # yes, this uses knowledge of where the proving grounds is
+    $LOAD_PATH.unshift File.expand_path "{{Haiti.config.proving_grounds_dir}}/../lib", __FILE__
+
+    require 'seeing_is_believing'
+    result = SeeingIsBelieving::Result.new
+    result.record_result(1, /omg/)
+
+    require 'yaml'
+    puts YAML.dump result
+    """
+    When I run "chmod +x fake_ruby"
+    When I run "seeing_is_believing -e 123 --shebang ./fake_ruby"
+    Then stdout is "123  # => /omg/"

data/lib/seeing_is_believing/binary/add_annotations.rb

@@ -26,13 +26,14 @@ class SeeingIsBelieving
         self.options = options
         self.body    = CleanBody.call uncleaned_body, !xmpfilter_style
         self.results = SeeingIsBelieving.call body,
-                                              filename:     (options[:as] || options[:filename]),
-                                              require:      options[:require],
-                                              load_path:    options[:load_path],
-                                              encoding:     options[:encoding],
-                                              stdin:        options[:stdin],
-                                              timeout:      options[:timeout],
-                                              debugger:     debugger
+                                              filename:        (options[:as] || options[:filename]),
+                                              require:         options[:require],
+                                              load_path:       options[:load_path],
+                                              encoding:        options[:encoding],
+                                              stdin:           options[:stdin],
+                                              timeout:         options[:timeout],
+                                              debugger:        debugger,
+                                              ruby_executable: options[:shebang]
       end
 
       def call
@@ -81,11 +82,8 @@ class SeeingIsBelieving
             new_body << output
           end
 
-          new_body = if debugger.enabled?
-            debugger.context("OUTPUT") { new_body }.to_s
-          else
-            new_body
-          end
+          debugger.context "OUTPUT"
+          new_body
         end
       end
 

data/lib/seeing_is_believing/binary/clean_body.rb

@@ -3,7 +3,7 @@
 #   removes annotations
 #   only removes "# =>" when should_clean_values is false
 
-require 'parser/current'
+require 'seeing_is_believing/parser_helpers'
 
 class SeeingIsBelieving
   class Binary
@@ -18,11 +18,7 @@ class SeeingIsBelieving
       end
 
       def call
-        buffer                = Parser::Source::Buffer.new "strip_comments"
-        buffer.source         = code
-        parser                = Parser::CurrentRuby.new
-        rewriter              = Parser::Source::Rewriter.new(buffer)
-        ast, comments         = parser.parse_with_comments(buffer)
+        buffer, parser, rewriter, ast, comments = ParserHelpers.initialize_parser code, 'strip_comments'
         removed_comments      = { result: [], exception: [], stdout: [], stderr: [] }
 
         comments.each do |comment|

data/lib/seeing_is_believing/binary/commentable_lines.rb

@@ -1,15 +1,19 @@
-require 'parser/current'
+require 'seeing_is_believing/parser_helpers'
 
 class SeeingIsBelieving
   class Binary
-
     class CommentableLines
+
+      include ParserHelpers
+
       def self.call(code)
         new(code).call
       end
 
       def initialize(code)
         self.code = code
+        self.buffer, self.parser, self.rewriter, self.root, self.comments =
+          initialize_parser(code, 'strip_comments')
       end
 
       def call
@@ -23,37 +27,12 @@ class SeeingIsBelieving
         end
       end
 
-      def buffer
-        @buffer ||= Parser::Source::Buffer.new("strip_comments").tap { |b| b.source = code }
-      end
-
-      def rewriter
-        @rewriter ||= Parser::Source::Rewriter.new(buffer)
-      end
+      attr_reader :buffer, :rewriter
 
       private
 
-      attr_accessor :code
-
-      def parser
-        @parser ||= Parser::CurrentRuby.new
-      end
-
-      def root
-        parse!
-        @root
-      end
-
-      def comments
-        parse!
-        @comments
-      end
-
-
-      def parse!
-        return if @root
-        @root, @comments = parser.parse_with_comments(buffer)
-      end
+      attr_writer :buffer, :rewriter
+      attr_accessor :code, :parser, :root, :comments
 
       def line_nums_to_last_index_and_col(buffer)
         line_num_to_indexes = code.each_char
@@ -126,19 +105,6 @@ class SeeingIsBelieving
         end
       end
 
-      # copy/pasted from wrap_expressions
-      def heredoc?(ast)
-        # some strings are fucking weird.
-        # e.g. the "1" in `%w[1]` returns nil for ast.location.begin
-        # and `__FILE__` is a string whose location is a Parser::Source::Map instead of a Parser::Source::Map::Collection, so it has no #begin
-        ast.kind_of?(Parser::AST::Node)           &&
-          (ast.type == :dstr || ast.type == :str) &&
-          (location  = ast.location)              &&
-          (location.respond_to?(:begin))          &&
-          (the_begin = location.begin)            &&
-          (the_begin.source =~ /^\<\<-?/)
-      end
-
       def remove_lines_after_data_segment(line_num_to_indexes)
         data_segment_line, _ = line_num_to_indexes.find do |line_number, (end_index, col)|
           if end_index == 7

data/lib/seeing_is_believing/binary/{arg_parser.rb → parse_args.rb}

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'stringio'
 require 'seeing_is_believing/version'
 require 'seeing_is_believing/debugger'
@@ -7,16 +9,15 @@ require 'seeing_is_believing/binary/align_chunk'
 
 class SeeingIsBelieving
   class Binary
-    class ArgParser
-      def self.parse(args)
-        new(args).call
+    class ParseArgs
+      def self.call(args, outstream)
+        new(args, outstream).call
       end
 
-      attr_accessor :args
-
-      def initialize(args)
+      def initialize(args, outstream)
         self.args      = args
         self.filenames = []
+        self.outstream = outstream
       end
 
       def call
@@ -28,16 +29,17 @@ class SeeingIsBelieving
             when '-v', '--version'             then options[:version]             = true
             when '-x', '--xmpfilter-style'     then options[:xmpfilter_style]     = true
             when '-i', '--inherit-exit-status' then options[:inherit_exit_status] = true
-            when '-g', '--debug'               then options[:debugger]            = Debugger.new(enabled: true, colour: true)
+            when '-g', '--debug'               then options[:debugger]            = Debugger.new(stream: outstream, colour: 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 :max_line_length,   arg
             when '-D', '--result-length'       then extract_positive_int_for :max_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 '-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       '--shebang'             then next_arg("#{arg} expects a ruby executable as the following argument but did not see one") { |executable| options[:shebang]   = executable }
             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 }
@@ -54,7 +56,8 @@ class SeeingIsBelieving
 
       private
 
-      attr_accessor :filenames
+      attr_accessor :filenames, :args, :outstream
+
 
       def normalize_and_validate
         if 1 < filenames.size
@@ -70,7 +73,7 @@ class SeeingIsBelieving
 
       def options
         @options ||= {
-          debugger:            Debugger.new(enabled: false, colour: true),
+          debugger:            Debugger.new(stream: nil),
           version:             false,
           clean:               false,
           xmpfilter_style:     false,
@@ -86,6 +89,7 @@ class SeeingIsBelieving
           require:             [],
           load_path:           [],
           alignment_strategy:  AlignChunk,
+          shebang:             'ruby',
         }
       end
 
@@ -130,7 +134,7 @@ class SeeingIsBelieving
 
     end
 
-    def ArgParser.help_screen
+    def ParseArgs.help_screen
 <<HELP_SCREEN
 Usage: seeing_is_believing [options] [filename]
 
@@ -156,8 +160,92 @@ Usage: seeing_is_believing [options] [filename]
   -g, --debug                   # print debugging information (useful if program is fucking up, or if you want to brag)
   -x, --xmpfilter-style         # annotate marked lines instead of every line
   -i, --inherit-exit-status     # exit with the exit status of the program being eval
+      --shebang ruby-executable # if you want SiB to use some ruby other than the one in the path
   -v, --version                 # print the version (#{VERSION})
   -h, --help                    # this help screen
+
+Examples: A few examples, for a more comprehensive set of examples, check out features/flags.feature
+
+  Run the file f.rb
+    $ echo __FILE__ > f.rb; seeing_is_believing f.rb
+    __FILE__  # => "f.rb"
+
+  Aligning comments
+    $ ruby -e 'puts "123\\n4\\n\\n567890"' > f.rb
+
+
+    $ seeing_is_believing f.rb -s line
+    123  # => 123
+    4  # => 4
+
+    567890  # => 567890
+
+
+    $ seeing_is_believing f.rb -s chunk
+    123  # => 123
+    4    # => 4
+
+    567890  # => 567890
+
+
+    $ seeing_is_believing f.rb -s file
+    123     # => 123
+    4       # => 4
+
+    567890  # => 567890
+
+  Run against standard input
+    $ echo '3.times { |i| puts i }' | seeing_is_believing
+    2.times { |i| puts i }  # => 2
+
+    # >> 0
+    # >> 1
+
+  Run against a library you're working on by fixing the load path
+    $ seeing_is_believing -I lib f.rb
+
+  Load up some library (can be used in tandem with -I)
+    $ seeing_is_believing -r pp -e 'pp [[*1..15],[*15..30]]; nil'
+    pp [[*1..15],[*15..30]]; nil  # => nil
+
+    # >> [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    # >>  [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]]
+
+  Only update the lines you've marked
+    $ ruby -e 'puts "1\\n2 # =>\\n3"' | seeing_is_believing -x
+    1
+    2 # => 2
+    3
+
+  Set a timeout (especially useful if running via an editor)
+    $ seeing_is_believing -e 'loop { sleep 1 }' -t 3
+    Timeout Error after 3.0 seconds!
+
+  Set the encoding to utf-8
+    $ seeing_is_believing -Ku -e '"⛄ "'
+    "⛄ "  # => "⛄ "
+
+  The exit status will be 1 if the error is displayable inline
+    $ seeing_is_believing -e 'raise "omg"'; echo $?
+    raise "omg"  # ~> RuntimeError: omg
+    1
+
+  The exit status will be 2 if the error is not displayable
+    $ seeing_is_believing -e 'a='; echo $status
+    -:1: syntax error, unexpected $end
+    2
+
+  Run with previous output
+    $ echo "1+1  # => old-value" | seeing_is_believing
+    1+1  # => 2
+
+    $ echo "1+1  # => old-value" | seeing_is_believing --clean
+    1+1
+
+  If your Ruby binary is named something else (e.g. ruby2.0)
+    $ ruby2.0 -S seeing_is_believing --shebang ruby2.0 -e '123'
+    123  # => 123
+
 HELP_SCREEN
     end
   end

data/lib/seeing_is_believing/binary/rewrite_comments.rb

@@ -1,14 +1,10 @@
-require 'parser/current'
+require 'seeing_is_believing/parser_helpers'
 
 class SeeingIsBelieving
   class Binary
     module RewriteComments
       def self.call(code, &mapping)
-        buffer        = Parser::Source::Buffer.new "strip_comments"
-        buffer.source = code
-        parser        = Parser::CurrentRuby.new
-        rewriter      = Parser::Source::Rewriter.new(buffer)
-        ast, comments = parser.parse_with_comments(buffer)
+        buffer, parser, rewriter, ast, comments = ParserHelpers.initialize_parser code, 'strip_comments'
 
         comments.each do |comment|
           next unless comment.type == :inline

data/lib/seeing_is_believing/binary.rb

@@ -1,5 +1,5 @@
 require 'seeing_is_believing'
-require 'seeing_is_believing/binary/arg_parser'
+require 'seeing_is_believing/binary/parse_args'
 require 'seeing_is_believing/binary/add_annotations'
 require 'seeing_is_believing/binary/clean_body'
 require 'timeout'
@@ -52,7 +52,7 @@ class SeeingIsBelieving
     end
 
     def parse_flags
-      self.flags = ArgParser.parse argv
+      self.flags = ParseArgs.call argv, stdout
     end
 
     def has_filename?
@@ -86,7 +86,11 @@ class SeeingIsBelieving
     end
 
     def print_unexpected_error
-      stderr.puts unexpected_exception.class, unexpected_exception.message, "", unexpected_exception.backtrace
+      if unexpected_exception.kind_of? BugInSib
+        stderr.puts unexpected_exception.message
+      else
+        stderr.puts unexpected_exception.class, unexpected_exception.message, "", unexpected_exception.backtrace
+      end
     end
 
     def printer
@@ -138,7 +142,7 @@ class SeeingIsBelieving
     end
 
     def syntax_error_notice
-      out, err, syntax_status = Open3.capture3 'ruby', '-c', stdin_data: body
+      out, err, syntax_status = Open3.capture3 flags[:shebang], '-c', stdin_data: body
       return err unless syntax_status.success?
     end
 

data/lib/seeing_is_believing/debugger.rb

@@ -5,32 +5,27 @@ class SeeingIsBelieving
     RESET_COLOUR   = "\e[0m"
 
     def initialize(options={})
-      @contexts = Hash.new { |h, k| h[k] = [] }
-      @enabled  = options.fetch :enabled, true
-      @coloured = options.fetch :colour,  false
-    end
-
-    def enabled?
-      @enabled
+      @coloured = options[:colour]
+      @stream   = options[:stream]
     end
 
     def coloured?
       @coloured
     end
 
+    attr_reader :stream
+    alias enabled? stream
+
     def context(name, &block)
-      @contexts[name] << block.call if enabled?
+      if stream
+        stream << CONTEXT_COLOUR          if coloured?
+        stream << "#{name}:"
+        stream << RESET_COLOUR            if coloured?
+        stream << "\n"
+        stream << block.call.to_s << "\n" if block
+      end
       self
     end
 
-    def to_s
-      @contexts.map { |name, values|
-        string = ""
-        string << CONTEXT_COLOUR if coloured?
-        string << "#{name}:"
-        string << RESET_COLOUR if coloured?
-        string << "\n#{values.join "\n"}\n"
-      }.join("\n")
-    end
   end
 end

data/lib/seeing_is_believing/error.rb

@@ -11,4 +11,18 @@ class SeeingIsBelieving
             " then delete TEMPFILE. Otherwise rename TEMPFILE to FILE."
     end
   end
+
+  class BugInSib < SeeingIsBelievingError
+    def initialize(error)
+      require 'parser/version'
+      require 'seeing_is_believing/version'
+
+      super "It blew up >.< Please log an issue at: https://github.com/JoshCheek/seeing_is_believing/issues\n"\
+            "SeeingIsBelieving::VERSION  #{SeeingIsBelieving::VERSION.inspect}\n"\
+            "Parser::VERSION             #{Parser::VERSION.inspect}\n"\
+            "RUBY_VERSION                #{RUBY_VERSION.inspect}\n"\
+            "ENV['RUBY_VERSION']         #{ENV['RUBY_VERSION'].inspect}\n"\
+            "Also include the source code of program that caused this behaviour."
+    end
+  end
 end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -18,22 +18,24 @@ require 'stringio'
 require 'fileutils'
 require 'seeing_is_believing/error'
 require 'seeing_is_believing/result'
+require 'seeing_is_believing/debugger'
 require 'seeing_is_believing/hard_core_ensure'
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
-    attr_accessor :program, :filename, :error_stream, :input_stream, :matrix_filename, :require_flags, :load_path_flags, :encoding, :timeout
+    attr_accessor :program, :filename, :input_stream, :matrix_filename, :require_flags, :load_path_flags, :encoding, :timeout, :ruby_executable, :debugger
 
     def initialize(program, filename, options={})
       self.program         = program
       self.filename        = filename
-      self.error_stream    = options.fetch :error_stream, $stderr # hmm, not really liking the global here
       self.input_stream    = options.fetch :input_stream, StringIO.new('')
       self.matrix_filename = options[:matrix_filename] || 'seeing_is_believing/the_matrix'
       self.require_flags   = options.fetch(:require, []).map { |filename| ['-r', filename] }.flatten
       self.load_path_flags = options.fetch(:load_path, []).map { |dir| ['-I', dir] }.flatten
       self.encoding        = options.fetch :encoding, nil
       self.timeout         = options[:timeout]
+      self.ruby_executable = options.fetch :ruby_executable, 'ruby'
+      self.debugger        = options.fetch :debugger, Debugger.new(stream: nil)
     end
 
     def call
@@ -47,9 +49,9 @@ class SeeingIsBelieving
             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
-            notify_user_of_error if error_implies_bug_in_sib? $!
-            raise $!
+          rescue Exception => error
+            error = wrap_error error if error_implies_bug_in_sib? error
+            raise error
           end
         },
         ensure: -> {
@@ -117,7 +119,7 @@ class SeeingIsBelieving
     end
 
     def popen_args
-      ['ruby',
+      [ruby_executable,
          '-W0',                                     # no warnings (b/c I hijack STDOUT/STDERR)
          *(encoding ? ["-K#{encoding}"] : []),      # allow the encoding to be set
          '-I', File.expand_path('../..', __FILE__), # add lib to the load path
@@ -135,17 +137,14 @@ class SeeingIsBelieving
       YAML.load stdout
     end
 
-    def notify_user_of_error
-      error_stream.puts "It blew up because SeeingIsBelieving isn't good enough >.<"
-      error_stream.puts "Please log an issue at: https://github.com/JoshCheek/seeing_is_believing/issues"
-      error_stream.puts
-      error_stream.puts "Program: #{program.inspect}"
-      error_stream.puts
-      error_stream.puts "Stdout: #{stdout.inspect}"
-      error_stream.puts
-      error_stream.puts "Stderr: #{stderr.inspect}"
-      error_stream.puts
-      error_stream.puts "Status: #{exitstatus.inspect}"
+    def wrap_error(error)
+      debugger.context "Program could not be evaluated" do
+        "Program: #{program.inspect.chomp}\n\n"\
+        "Stdout: #{stdout.inspect.chomp}\n\n"\
+        "Stderr: #{stderr.inspect.chomp}\n\n"\
+        "Status: #{exitstatus.inspect.chomp}\n"
+      end
+      BugInSib.new error
     end
   end
 end

data/lib/seeing_is_believing/parser_helpers.rb

@@ -0,0 +1,51 @@
+require 'parser/current'
+class SeeingIsBelieving
+  module ParserHelpers
+    extend self
+
+    def initialize_parser(code, name)
+      buffer         = Parser::Source::Buffer.new(name)
+      buffer.source  = code
+      parser         = Parser::CurrentRuby.new
+      root, comments = parser.parse_with_comments buffer
+      rewriter       = Parser::Source::Rewriter.new buffer
+      [buffer, parser, rewriter, root, comments]
+    end
+
+    # this is the scardest fucking method I think I've ever written.
+    # *anything* can go wrong!
+    def heredoc?(ast)
+      # some strings are fucking weird.
+      # e.g. the "1" in `%w[1]` returns nil for ast.location.begin
+      # and `__FILE__` is a string whose location is a Parser::Source::Map instead of a Parser::Source::Map::Collection, so it has no #begin
+      ast.kind_of?(Parser::AST::Node)           &&
+        (ast.type == :dstr || ast.type == :str) &&
+        (location  = ast.location)              &&
+        (location.respond_to?(:begin))          &&
+        (the_begin = location.begin)            &&
+        (the_begin.source =~ /^\<\<-?/)
+    end
+
+    def void_value?(ast)
+      case ast && ast.type
+      when :begin, :kwbegin, :resbody
+        void_value?(ast.children[-1])
+      when :rescue, :ensure
+        ast.children.any? { |child| void_value? child }
+      when :if
+        void_value?(ast.children[1]) || void_value?(ast.children[2])
+      when :return, :next, :redo, :retry, :break
+        true
+      else
+        false
+      end
+    end
+
+    def heredoc_hack(ast)
+      return ast unless heredoc? ast
+      Parser::AST::Node.new :str,
+                            [],
+                            location: Parser::Source::Map.new(ast.location.begin)
+    end
+  end
+end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '2.0.0.beta2'
+  VERSION = '2.0.0.beta3'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -1,4 +1,5 @@
 require 'parser/current'
+require 'seeing_is_believing/parser_helpers'
 
 # hack rewriter to apply insertions in stable order
 # until https://github.com/whitequark/parser/pull/102 gets released
@@ -31,6 +32,9 @@ end
 # https://github.com/whitequark/parser/blob/master/doc/AST_FORMAT.md
 class SeeingIsBelieving
   class WrapExpressions
+
+    include ParserHelpers
+
     def self.call(program, wrappings)
       new(program, wrappings).call
     end
@@ -41,10 +45,7 @@ class SeeingIsBelieving
       self.after_all   = wrappings.fetch :after_all,   ''.freeze
       self.before_each = wrappings.fetch :before_each, -> * { '' }
       self.after_each  = wrappings.fetch :after_each,  -> * { '' }
-      self.buffer      = Parser::Source::Buffer.new('program-without-annotations')
-      buffer.source    = program
-      self.root        = Parser::CurrentRuby.new.parse buffer
-      self.rewriter    = Parser::Source::Rewriter.new buffer
+      self.buffer, _, self.rewriter, self.root, _ = initialize_parser(program, 'program-without-annotations')
       self.wrappings   = {}
     rescue Parser::SyntaxError => e
       raise ::SyntaxError, e.message
@@ -190,6 +191,13 @@ class SeeingIsBelieving
             end_pos += 1
           end
 
+        # target is a heredoc, so we can't trust the expression
+        # but method has parens, so we can't trust the last arg
+        elsif heredoc?(target) && last_arg && buffer.source[ast.location.selector.end_pos] == '('
+          end_pos = last_arg.location.expression.end_pos
+          end_pos += 1 until buffer.source[end_pos] == ')'
+          end_pos += 1
+
         elsif heredoc?(target) && last_arg
           end_pos = last_arg.location.expression.end_pos
 
@@ -238,51 +246,6 @@ class SeeingIsBelieving
         add_to_wrappings ast
         add_children ast
       end
-    rescue
-      # TODO: delete this rescue block once things get stabler
-      puts ast.type
-      puts $!
-      require "pry"
-      binding.pry
-      raise
-    end
-
-    def heredoc_hack(ast)
-      return ast unless heredoc? ast
-      Parser::AST::Node.new :str,
-                            [],
-                            location: Parser::Source::Map.new(ast.location.begin)
-    end
-
-    # this is the scardest fucking method I think I've ever written.
-    # *anything* can go wrong!
-    #
-    # !!NOTE!! This method is copy/pasted into Binary::CommentLines
-    def heredoc?(ast)
-      # some strings are fucking weird.
-      # e.g. the "1" in `%w[1]` returns nil for ast.location.begin
-      # and `__FILE__` is a string whose location is a Parser::Source::Map instead of a Parser::Source::Map::Collection, so it has no #begin
-      ast.kind_of?(Parser::AST::Node)           &&
-        (ast.type == :dstr || ast.type == :str) &&
-        (location  = ast.location)              &&
-        (location.respond_to?(:begin))          &&
-        (the_begin = location.begin)            &&
-        (the_begin.source =~ /^\<\<-?/)
-    end
-
-    def void_value?(ast)
-      case ast && ast.type
-      when :begin, :kwbegin, :resbody
-        void_value?(ast.children[-1])
-      when :rescue, :ensure
-        ast.children.any? { |child| void_value? child }
-      when :if
-        void_value?(ast.children[1]) || void_value?(ast.children[2])
-      when :return, :next, :redo, :retry, :break
-        true
-      else
-        false
-      end
     end
   end
 end

data/lib/seeing_is_believing.rb

@@ -25,7 +25,8 @@ class SeeingIsBelieving
     @load_path       = options.fetch :load_path, []
     @encoding        = options.fetch :encoding, nil
     @timeout         = options[:timeout]
-    @debugger        = options.fetch :debugger, Debugger.new(enabled: false)
+    @debugger        = options.fetch :debugger, Debugger.new(stream: nil)
+    @ruby_executable = options.fetch :ruby_executable, 'ruby'
   end
 
   def call
@@ -70,7 +71,9 @@ class SeeingIsBelieving
                                 require:         @require,
                                 load_path:       @load_path,
                                 encoding:        @encoding,
-                                timeout:         @timeout)
+                                timeout:         @timeout,
+                                ruby_executable: @ruby_executable,
+                                debugger:        @debugger)
                            .call
     end
   end

data/seeing_is_believing.gemspec

@@ -19,7 +19,7 @@ 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",   "~> 2.0.0.pre6"
+  s.add_dependency             "parser",   "= 2.0.0.pre6"
 
   s.add_development_dependency "haiti",    "~> 0.0.3"
   s.add_development_dependency "rake",     "~> 10.0.3"

data/spec/binary/arg_parser_spec.rb

@@ -1,6 +1,6 @@
-require 'seeing_is_believing/binary/arg_parser'
+require 'seeing_is_believing/binary/parse_args'
 
-describe SeeingIsBelieving::Binary::ArgParser do
+describe SeeingIsBelieving::Binary::ParseArgs do
   RSpec::Matchers.define :have_error do |error_assertion|
     match do |options|
       options[:errors].find do |error|
@@ -22,8 +22,8 @@ describe SeeingIsBelieving::Binary::ArgParser do
     end
   end
 
-  def parse(args)
-    described_class.parse args
+  def parse(args, outstream=nil)
+    described_class.call args, outstream
   end
 
   shared_examples 'it requires a positive int argument' do |flags|
@@ -336,12 +336,31 @@ describe SeeingIsBelieving::Binary::ArgParser do
 
   describe ':debugger' do
     it 'defaults to a debugger that is disabled' do
-      parse([])[:debugger].should_not be_enabled
+      parse([], :fake_stream)[:debugger].should_not be_enabled
     end
 
     it 'can be enabled with --debug or -g' do
-      parse(['--debug'])[:debugger].should be_enabled
-      parse(['-g'])[:debugger].should be_enabled
+      parse(['--debug'], :fake_stream)[:debugger].should be_enabled
+      parse(['-g'], :fake_stream)[:debugger].should be_enabled
+    end
+
+    it 'sets the stream to the one passed in' do
+      parse(['-g'], :fake_stream)[:debugger].stream.should == :fake_stream
+    end
+  end
+
+  describe ':shebang' do
+    it 'defaults to "ruby"' do
+      parse([])[:shebang].should == 'ruby'
+    end
+
+    it 'can be enabled with --shebang' do
+      parse(['--shebang', 'not_ruby'])[:shebang].should == 'not_ruby'
+    end
+
+    it 'sets an error if not given a next arg to execute' do
+      parse([]).should_not have_error /--shebang/
+      parse(['--shebang']).should have_error /--shebang/
     end
   end
 end

data/spec/debugger_spec.rb

@@ -1,27 +1,40 @@
 require 'seeing_is_believing/debugger'
+require 'stringio'
 
 describe SeeingIsBelieving::Debugger do
-  specify 'the debugger is enabled by default' do
-    described_class.new.should be_enabled
-    described_class.new(enabled: true).should be_enabled
-    described_class.new(enabled: false).should_not be_enabled
+  let(:stream) { StringIO.new }
+
+  specify 'is enabled when given a stream' do
+    described_class.new(stream: nil).should_not be_enabled
+    described_class.new(stream: stream).should be_enabled
   end
 
-  it 'does not evaluate its contexts when disabled' do
-    expect { described_class.new(enabled:  true).context('c') { raise 'omg' } }.to raise_error 'omg'
-    expect { described_class.new(enabled: false).context('c') { raise 'omg' } }.to_not raise_error
+  specify 'colour is disabled by default' do
+    described_class.new.should_not be_coloured
+    described_class.new(colour: false).should_not be_coloured
+    described_class.new(colour:  true).should be_coloured
   end
 
-  it 'caches results under a name which all appear consecutively next to eachother regardless of when they were called' do
-    described_class.new(enabled: true, color: false)
-                   .context('a') { '1' }
-                   .context('b') { '3' }
-                   .context('a') { '2' }
-                   .to_s.should == "a:\n1\n2\n\nb:\n3\n"
+  context 'when given a steram' do
+    it 'prints the the context and the value of the block' do
+      described_class.new(stream: stream).context('C') { 'V' }
+      stream.string.should == "C:\nV\n"
+    end
+
+    it 'colours the context when colour is set to true' do
+      described_class.new(stream: stream, colour: true).context('C') { 'V' }
+      stream.string.should == "#{described_class::CONTEXT_COLOUR}C:#{described_class::RESET_COLOUR}\nV\n"
+    end
   end
 
-  specify 'colouring is disabled by default' do
-    described_class.new(enabled: true, colour: true).context('AAA') { 'BBB' }.to_s.should ==
-      "#{described_class::CONTEXT_COLOUR}AAA:#{described_class::RESET_COLOUR}\nBBB\n"
+  context 'when not given a stream' do
+    it 'prints nothing' do
+      described_class.new.context('C') { 'V' }
+      stream.string.should be_empty
+    end
+
+    it 'does not evaluate the blocks' do
+      described_class.new.context('C') { fail }
+    end
   end
 end

data/spec/evaluate_by_moving_files_spec.rb

@@ -42,7 +42,7 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'uses HardCoreEnsure to move the file back' do
-    evaluator = described_class.new 'PROGRAM', filename, error_stream: StringIO.new
+    evaluator = described_class.new 'PROGRAM', filename
     File.open(filename, 'w') { |f| f.write 'ORIGINAL' }
     FileUtils.rm_rf evaluator.temp_filename
     SeeingIsBelieving::HardCoreEnsure.should_receive(:call) do |options|
@@ -64,7 +64,7 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'uses HardCoreEnsure to delete the file if it wrote it where one did not previously exist' do
-    evaluator = described_class.new 'PROGRAM', filename, error_stream: StringIO.new
+    evaluator = described_class.new 'PROGRAM', filename
     FileUtils.rm_rf filename
     SeeingIsBelieving::HardCoreEnsure.should_receive(:call) do |options|
       # initial state
@@ -100,11 +100,11 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
     invoke('print "ç"', encoding: 'u').stdout.should == "ç"
   end
 
-  it 'prints some error handling code to stderr if it fails' do
-    stderr    = StringIO.new
-    evaluator = described_class.new 'raise "omg"', filename, error_stream: stderr
+  it 'if it fails, it prints some debugging information and raises an error', t:true do
+    error_stream = StringIO.new
+    evaluator = described_class.new 'raise "omg"', filename, debugger: SeeingIsBelieving::Debugger.new(stream: error_stream)
     FileUtils.rm_f evaluator.temp_filename
-    expect { evaluator.call }.to raise_error
-    stderr.string.should include "It blew up"
+    expect { evaluator.call }.to raise_error SeeingIsBelieving::BugInSib
+    error_stream.string.should include "Program could not be evaluated"
   end
 end

data/spec/seeing_is_believing_spec.rb

@@ -7,8 +7,8 @@ describe SeeingIsBelieving do
     described_class.new(input, options).call
   end
 
-  def values_for(input)
-    invoke(input).to_a
+  def values_for(input, options={})
+    invoke(input, options).to_a
   end
 
   let(:proving_grounds_dir) { File.expand_path '../../proving_grounds', __FILE__ }
@@ -296,8 +296,32 @@ describe SeeingIsBelieving do
                                                   ['[6, 12]']]
   end
 
+  it 'can evaluate under a different ruby executable' do
+    Dir.chdir proving_grounds_dir 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 'yaml'
+        puts YAML.dump result
+      "
+      File.chmod 0755, 'omg-ruby'
+      old_path = ENV['PATH']
+      ENV['PATH'] = "#{proving_grounds_dir}:#{old_path}"
+      begin
+        values_for("1", ruby_executable: 'omg-ruby').should == [["/omg/"]]
+      ensure
+        ENV['PATH'] = old_path
+      end
+    end
+  end
+
   context 'when given a debugger' do
-    let(:debugger) { SeeingIsBelieving::Debugger.new enabled: true }
+    let(:stream)   { StringIO.new }
+    let(:debugger) { SeeingIsBelieving::Debugger.new stream: stream }
 
     def call
       invoke "1", debugger: debugger
@@ -305,14 +329,14 @@ describe SeeingIsBelieving do
 
     it 'prints the pre-evaluated program' do
       call
-      debugger.to_s.should include "TRANSLATED PROGRAM:"
-      debugger.to_s.should include "\nbegin;" # there is more, but we're just interested in showing that it wound up in the stream
+      stream.string.should include "TRANSLATED PROGRAM:"
+      stream.string.should include "\nbegin;" # there is more, but we're just interested in showing that it wound up in the stream
     end
 
     it 'prints the result' do
       call
-      debugger.to_s.should include "RESULT:"
-      debugger.to_s.should include '1=>#<SIB:Line["1"] no exception>'
+      stream.string.should include "RESULT:"
+      stream.string.should include '1=>#<SIB:Line["1"] no exception>'
     end
     # should ProgramRewriter have some debug options?
   end

data/spec/wrap_expressions_spec.rb

@@ -384,7 +384,6 @@ describe SeeingIsBelieving::WrapExpressions do
       wrap("$a  ||= begin\n123\nend").should == "<$a  ||= begin\n<123>\nend>"
       wrap("@@a ||= begin\n123\nend").should == "<@@a ||= begin\n<123>\nend>"
       wrap("B   ||= begin\n123\nend").should == "<B   ||= begin\n<123>\nend>"
-      wrap("::B ||= begin\n123\nend").should == "<::B ||= begin\n<123>\nend>"
     end
 
     it 'wraps arguments in the assignment' do
@@ -630,6 +629,7 @@ describe SeeingIsBelieving::WrapExpressions do
     it 'wraps methods tacked onto the end of heredocs' do
       wrap("<<A.size\nA").should == "<<<A.size>\nA"
       wrap("<<A.size 1\nA").should == "<<<A.size 1>\nA"
+      wrap("<<A.size(1)\nA").should == "<<<A.size(1)>\nA"
       wrap("<<A.whatever <<B\nA\nB").should == "<<<A.whatever <<B>\nA\nB"
       wrap("<<A.whatever(<<B)\nA\nB").should == "<<<A.whatever(<<B)>\nA\nB"
       wrap("<<A.size()\nA").should == "<<<A.size()>\nA"

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.0.0.beta3
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
         version: 2.0.0.pre6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
         version: 2.0.0.pre6
 - !ruby/object:Gem::Dependency
@@ -121,11 +121,11 @@ files:
 - lib/seeing_is_believing/binary/align_chunk.rb
 - lib/seeing_is_believing/binary/align_file.rb
 - lib/seeing_is_believing/binary/align_line.rb
-- lib/seeing_is_believing/binary/arg_parser.rb
 - lib/seeing_is_believing/binary/clean_body.rb
 - lib/seeing_is_believing/binary/comment_formatter.rb
 - lib/seeing_is_believing/binary/comment_lines.rb
 - lib/seeing_is_believing/binary/commentable_lines.rb
+- lib/seeing_is_believing/binary/parse_args.rb
 - lib/seeing_is_believing/binary/rewrite_comments.rb
 - lib/seeing_is_believing/debugger.rb
 - lib/seeing_is_believing/error.rb
@@ -133,6 +133,7 @@ files:
 - lib/seeing_is_believing/hard_core_ensure.rb
 - lib/seeing_is_believing/has_exception.rb
 - lib/seeing_is_believing/line.rb
+- lib/seeing_is_believing/parser_helpers.rb
 - lib/seeing_is_believing/result.rb
 - lib/seeing_is_believing/the_matrix.rb
 - lib/seeing_is_believing/version.rb