seeing_is_believing 2.0.0.beta3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a95d8680853f82d8aee58a8ba40d16a113662f20
-  data.tar.gz: 6e9fecb99be2adf05d75bb42d2c8a37de1ff1c7b
+  metadata.gz: ae86d44e9afffb2928ac761a5bf8f6810ec1c996
+  data.tar.gz: 4c37f23d51da74cde81e85f2c48b1928daeedce9
 SHA512:
-  metadata.gz: 291941c2ca6975b233ecfe9f8428f40638331839ec29591d955333d49a3bf975ed0478ca67059e41a7583ddd8b18e9140a9f632b8242665d8fdfed939e8bf319
-  data.tar.gz: 138ae24e20da808a5ea5eb31bcc9ab4eede0163054a130478f79f1e00842b5c56b073f104c98c952f77e0b5698ca6e626691e4818137db136811eaa4e64fff30
+  metadata.gz: 08e8e66324e9360ee680327765f7d633a0862ab22237148ddd49d0bfc78ebfaa89f9466a4390dc5404126aa791256cbb437aa346ebbfc22c904a231fab042c35
+  data.tar.gz: bd56f998a57e28b06bcfc04782feb64ccb1e7466503cec372b08f9f77102a70df4c05dd7e9079f45b441ed2c72ded198d02aedc653c8be2c43d69448e48a286f

data/Readme.md

@@ -4,12 +4,12 @@ Seeing Is Believing
 ===================
 
 Evaluates a file, recording the results of each line of code.
-You can then use this to display output values like Bret Victor does with JavaScript in his talk [Inventing on Principle][inventing_on_principle].
+You can then use this to display output values like Bret Victor does with JavaScript in his talk [Inventing on Principle](http://vimeo.com/36579366).
 Except, obviously, his is like a million times better.
 
 Also comes with a binary to show how it might be used.
 
-For whatever reason, I can't embed videos, but **here's a ~1 minute [video][video]** showing it off.
+For whatever reason, I can't embed videos, but **here's a ~1 minute [video](http://vimeo.com/58766950)** showing it off.
 
 Works in Ruby 1.9 and 2.0
 
@@ -17,25 +17,16 @@ Use The Binary
 ==============
 
 ```ruby
-# $ seeing_is_believing proving_grounds/basic_functionality.rb
+$ cat simple_example.rb
 5.times do |i|
-  i * 2         # => 0, 2, 4, 6, 8
-end             # => 5
-
-def meth(n)
-  n             # => "12", "34"
-end             # => nil
+    i * 2
+end
 
-# some invocations
-meth "12"       # => "12"
-meth "34"       # => "34"
-```
 
-```ruby
-# $ bin/seeing_is_believing proving_grounds/raises_exception.rb
-1 + 1          # => 2
-raise "ZOMG!"  # ~> RuntimeError: ZOMG!
-1 + 1
+$ seeing_is_believing simple_example.rb
+5.times do |i|  # => 5
+    i * 2       # => 0, 2, 4, 6, 8
+end             # => 5
 ```
 
 Use The Lib
@@ -43,113 +34,38 @@ Use The Lib
 
 ```ruby
 require 'seeing_is_believing'
-
-believer = SeeingIsBelieving.new("%w[a b c].each do |i|
+believer = SeeingIsBelieving.new("[:a, :b, :c].each do |i|
                                     i.upcase
                                   end")
 
-result = believer.call
-result                # => #<SeeingIsBelieving::Result:0x007f832298e340 @max_line_number=3, @min_line_number=1, @results={2=>#<SeeingIsBelieving::Result::Line:0x007f832298df30 @array=["\"A\"", "\"B\"", "\"C\""]>, 3=>#<SeeingIsBelieving::Result::Line:0x007f832298db98 @array=["[\"a\", \"b\", \"c\"]"]>}, @stdout="", @stderr="">
-
-result.to_a           # => [#<SeeingIsBelieving::Result::Line:0x007f832299adc0 @array=[]>,
-                      #     #<SeeingIsBelieving::Result::Line:0x007f832298df30 @array=['"A"', '"B"', '"C"']>,
-                      #     #<SeeingIsBelieving::Result::Line:0x007f832298db98 @array=['["a", "b", "c"]']>]
+result = believer.call # => #<SIB::Result @results={1=>#<SIB:Line["[:a, :b, :c]"] no exception>, 2=>#<SIB:Line[":A", ":B", ":C"] no exception>, 3=>#<SIB:Line["[:a, :b, :c]"] no exception>}\n  @stdout=""\n  @stderr=""\n  @exitstatus=0\n  @bug_in_sib=nil>
 
-result[2]             # => #<SeeingIsBelieving::Result::Line:0x007f832298df30 @array=['"A"', '"B"', '"C"']>
+result[2]            # => #<SIB:Line[":A", ":B", ":C"] no exception>
+result[2][0]         # => ":A"
+result[2][1]         # => ":B"
+result[2][2]         # => ":C"
+result[2].join(", ") # => ":A, :B, :C"
 
-# this result object is a thin wrapper around its array
-result[2][0]          # => '"A"'
-result[2][1]          # => '"B"'
-result[2][2]          # => '"C"'
-result[2].join(", ")  # => '"A", "B", "C"'
+result.stdout    # => ""
+result.stderr    # => ""
+result.exception # => nil
 ```
 
 Install
 =======
 
+Currently requires Ruby 1.9 or 2.0 I don't have specific plans to make it available on 1.8,
+but it could happen.
 
     $ gem install seeing_is_believing
 
-Or if you haven't fixed your gem home, and you aren't using any version managers:
-
-    $ sudo gem install seeing_is_believing
-
-Rubygems is allowing pushes again, but if it goes back down, you can install like this:
-
-    $ git clone https://github.com/JoshCheek/seeing_is_believing/
-    $ cd seeing_is_believing
-    $ gem build seeing_is_believing.gemspec
-    $ gem install seeing_is_believing-0.0.8.gem
-    $ cd ..
-    $ rm -rf "./seeing_is_believing"
-
-Sublime Text 2 Integration
-==========================
-
-See [sublime-text-2-seeing-is-believing](https://github.com/JoshCheek/sublime-text-2-seeing-is-believing).
-
 
-TextMate Integration
-====================
+Editor 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 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 $default_options
-else
-  "${TM_RUBY}" -S seeing_is_believing $default_options --as "$TM_FILEPATH"
-fi
-```
-
-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"
-
-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
-```
-
-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
+* [sublime-text-2-seeing-is-believing](https://github.com/JoshCheek/sublime-text-2-seeing-is-believing)
+* [TextMate 1](https://github.com/JoshCheek/text_mate_1-seeing-is_believing)
+* [TextMate 2](https://github.com/JoshCheek/text_mate_2-seeing-is_believing)
 
 Emacs Integration
 =================
@@ -173,20 +89,15 @@ or current buffer contents with the output of running it through
 Known Issues
 ============
 
-* `BEGIN/END` breaks things and I probably won't take the time to fix it, becuase it's nontrivial and its really meant for command-line scripts, but there is currently a cuke for it
+* `BEGIN/END` breaks things and I probably won't ever fix it, becuase it's annoying and its really meant for command-line scripts... but there is currently a spec for it
 * `exit!` ignores callbacks that `SeeingIsBelieving` uses to communicate the results back to the main app. If you call it, `SeeingIsBelieving` will blow up. We could "fix" this by overriding it, but I feel like that would violate the meaning of `exit!`, so basically, just don't call that method.
+* The code to find the data segment is naive, and could wind up interpolating results into a string or something
 
 Todo
 ====
 
 * 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
-* Make sure the examples in this readme all still make sense (mountain berry fields?)
-* 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)
 ================================================================================
@@ -215,7 +126,3 @@ License
      0. You just DO WHAT THE FUCK YOU WANT TO.
 
 
-
-[inventing_on_principle]: http://vimeo.com/36579366
-[textmate-integration]:   https://raw.github.com/JoshCheek/seeing_is_believing/master/textmate-integration.png
-[video]:                  http://vimeo.com/58766950

data/features/errors.feature

@@ -93,7 +93,7 @@ Feature: Running the binary unsuccessfully
     """
 
   Scenario: Total Fucking Failure
-    Given the file "sib_will_utterly_die.rb" "BEGIN {}"
+    Given the file "sib_will_utterly_die.rb" "__TOTAL_FUCKING_FAILURE__"
     When I run "seeing_is_believing sib_will_utterly_die.rb"
     Then stderr is not empty
     And the exit status is 2

data/features/examples.feature

@@ -196,47 +196,6 @@ Feature: Running the binary successfully
     2
     """
 
-  @not-implemented
-  Scenario: Doesn't record BEGIN/END since that's apparently a syntax error
-    Given the file "BEGIN_and_END.rb":
-    """
-    puts 1
-    BEGIN {
-      puts "begin code"
-      some_var = 2
-    }
-    puts 3
-    END {
-      puts "end code"
-      puts some_var
-    }
-    puts 4
-    """
-    When I run "seeing_is_believing BEGIN_and_END.rb"
-    Then stderr is empty
-    And the exit status is 0
-    And stdout is:
-    """
-    puts 1               # => nil
-    BEGIN {
-      puts "begin code"  # => nil
-      some_var = 2       # => 2
-    }
-    puts 3               # => nil
-    END {
-      puts "end code"    # => nil
-      puts some_var      # => nil
-    }
-    puts 4               # => nil
-
-    # >> begin code
-    # >> 1
-    # >> 3
-    # >> 4
-    # >> end code
-    # >> 2
-    """
-
   Scenario: Reading from stdin
     Given the stdin content "hi!"
     And the file "reads_from_stdin.rb":

data/features/flags.feature

@@ -184,6 +184,19 @@ Feature: Using flags
     When I run "seeing_is_believing --line-length 14 line_lengths2.rb"
     Then stdout is "12345"
 
+  Scenario: --xmpfilter-style respects the line formatting (but not currently alignment strategies, it just preserves submitted alignment)
+    Given the file "line_lengths3.rb":
+    """
+    '1' * 30 # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style --line-length 19 line_lengths3.rb"
+    Then stdout is:
+    """
+    '1' * 30 # => "1...
+    # => "1111111111...
+    """
+
 
   Scenario: --require
     Given the file "print_1.rb" "puts 1"
@@ -292,7 +305,6 @@ Feature: Using flags
     """
 
 
-  @not-implemented
   Scenario: --clean on an invalid file will clean
     When I run 'seeing_is_believing --clean -e "1+  # => lkj"'
     Then stderr is empty

data/features/regression.feature

@@ -105,7 +105,7 @@ Feature:
     __END__
     """
     When I run "seeing_is_believing modified_result.rb"
-    Then stdout is:
+    Then stdout is exactly:
     """
     1  # => 1
     2  # => 2

data/features/support/env.rb

@@ -6,3 +6,7 @@ Haiti.configure do |config|
   config.bin_dir             = File.expand_path '../../../bin',             __FILE__
 end
 
+
+Then 'stdout is exactly:' do |code|
+  @last_executed.stdout.should == eval_curlies(code)
+end

data/lib/seeing_is_believing/binary.rb

@@ -11,6 +11,18 @@ class SeeingIsBelieving
     DISPLAYABLE_ERROR_STATUS    = 1 # e.g. there was an error, but the output is legit (we can display exceptions)
     NONDISPLAYABLE_ERROR_STATUS = 2 # e.g. an error like incorrect invocation or syntax that can't be displayed in the input program
 
+    VALUE_MARKER     = "# => "
+    EXCEPTION_MARKER = "# ~> "
+    STDOUT_MARKER    = "# >> "
+    STDERR_MARKER    = "# !> "
+
+    VALUE_REGEX      = /\A#\s*=>/
+    EXCEPTION_REGEX  = /\A#\s*~>/
+    STDOUT_REGEX     = /\A#\s*>>/
+    STDERR_REGEX     = /\A#\s*!>/
+
+
+
     attr_accessor :argv, :stdin, :stdout, :stderr, :timeout_error, :unexpected_exception
 
     def initialize(argv, stdin, stdout, stderr)
@@ -138,7 +150,7 @@ class SeeingIsBelieving
     end
 
     def print_program
-      stdout.puts interpolated_program
+      stdout.print interpolated_program
     end
 
     def syntax_error_notice

data/lib/seeing_is_believing/binary/add_annotations.rb

@@ -2,6 +2,7 @@ require 'stringio'
 require 'seeing_is_believing/has_exception'
 require 'seeing_is_believing/binary/comment_formatter'
 
+require 'seeing_is_believing/binary'
 require 'seeing_is_believing/binary/clean_body'
 require 'seeing_is_believing/binary/rewrite_comments'
 require 'seeing_is_believing/binary/comment_lines'
@@ -22,7 +23,7 @@ class SeeingIsBelieving
       method_from_options :debugger
 
       attr_accessor :results, :body
-      def initialize(uncleaned_body, options={})
+      def initialize(uncleaned_body, options={}, &annotater)
         self.options = options
         self.body    = CleanBody.call uncleaned_body, !xmpfilter_style
         self.results = SeeingIsBelieving.call body,
@@ -38,49 +39,13 @@ class SeeingIsBelieving
 
       def call
         @new_body ||= begin
-          # uhm, these basically look like strategies for commenting.
           new_body = if xmpfilter_style
-            RewriteComments.call body do |line_number, line, whitespace, comment|
-              # FIXME: can we centralize these regexes?
-              if !comment[/\A#\s*=>/]
-                [whitespace, comment]
-              elsif line.empty?
-                # should go through comment formatter
-                [whitespace, "# => #{results[line_number-1].map { |result| result.gsub "\n", '\n' }.join(', ')}"] # FIXME: NEED TO CONSIDER THE LINE LENGTH
-              else
-                # should go through comment formatter
-                [whitespace, "# => #{results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')}"] # FIXME: NEED TO CONSIDER THE LINE LENGTH
-              end
-            end
-          else
-            alignment_strategy = options[:alignment_strategy].new body, start_line, end_line
-            CommentLines.call body do |line, line_number|
-              options = options().merge pad_to: alignment_strategy.line_length_for(line_number)
-              if line_number < start_line || end_line < line_number
-                ''
-              elsif results[line_number].has_exception?
-                exception = results[line_number].exception
-                result    = sprintf "%s: %s", exception.class_name, exception.message.gsub("\n", '\n')
-                CommentFormatter.new(line.size, "# ~> ", result, options).call
-              elsif results[line_number].any?
-                result  = results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
-                CommentFormatter.call(line.size, "# => ", result, options)
-              else
-                ''
-              end
-            end
-          end
-
-          output = stdout_ouptut_for(results)    <<
-                   stderr_ouptut_for(results)    <<
-                   exception_output_for(results)
+                       body_with_updated_annotations
+                     else
+                       body_with_everything_annotated
+                     end
 
-          if new_body["\n__END__\n"]
-            new_body.sub! "\n__END__\n", "\n#{output}__END__\n"
-          else
-            new_body << "\n" unless new_body.end_with? "\n"
-            new_body << output
-          end
+          add_stdout_stderr_and_exceptions_to new_body
 
           debugger.context "OUTPUT"
           new_body
@@ -91,11 +56,60 @@ class SeeingIsBelieving
 
       attr_accessor :body, :options, :alignment_strategy
 
+      # doesn't currently realign output markers, do we want to do that?
+      def body_with_updated_annotations
+        RewriteComments.call body do |line_number, line_to_whitespace, whitespace, comment|
+          if !comment[VALUE_REGEX]
+            [whitespace, comment]
+          elsif line_to_whitespace.empty?
+            result = results[line_number-1].map { |result| result.gsub "\n", '\n' }.join(', ')
+            [whitespace, CommentFormatter.call(whitespace.size, VALUE_MARKER, result, options)]
+          else
+            result = results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+            [whitespace, CommentFormatter.call(line_to_whitespace.size + whitespace.size, VALUE_MARKER, result, options)]
+          end
+        end
+      end
+
+      def body_with_everything_annotated
+        alignment_strategy = options[:alignment_strategy].new body, start_line, end_line
+        CommentLines.call body do |line, line_number|
+          options = options().merge pad_to: alignment_strategy.line_length_for(line_number)
+          if line_number < start_line || end_line < line_number
+            ''
+          elsif results[line_number].has_exception?
+            exception = results[line_number].exception
+            result    = sprintf "%s: %s", exception.class_name, exception.message.gsub("\n", '\n')
+            CommentFormatter.call(line.size, EXCEPTION_MARKER, result, options)
+          elsif results[line_number].any?
+            result  = results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+            CommentFormatter.call(line.size, VALUE_MARKER, result, options)
+          else
+            ''
+          end
+        end
+      end
+
+      def add_stdout_stderr_and_exceptions_to(new_body)
+        output = stdout_ouptut_for(results)    <<
+                 stderr_ouptut_for(results)    <<
+                 exception_output_for(results)
+
+        # this technically could find an __END__ in a string or whatever
+        # going to just ignore that, though
+        if new_body[/^__END__$/]
+          new_body.sub! "\n__END__", "\n#{output}__END__"
+        else
+          new_body << "\n" unless new_body.end_with? "\n"
+          new_body << output
+        end
+      end
+
       def stdout_ouptut_for(results)
         return '' unless results.has_stdout?
         output = "\n"
         results.stdout.each_line do |line|
-          output << CommentFormatter.call(0, "# >> ", line.chomp, options()) << "\n"
+          output << CommentFormatter.call(0, STDOUT_MARKER, line.chomp, options()) << "\n"
         end
         output
       end
@@ -104,7 +118,7 @@ class SeeingIsBelieving
         return '' unless results.has_stderr?
         output = "\n"
         results.stderr.each_line do |line|
-          output << CommentFormatter.call(0, "# !> ", line.chomp, options()) << "\n"
+          output << CommentFormatter.call(0, STDERR_MARKER, line.chomp, options()) << "\n"
         end
         output
       end
@@ -113,13 +127,13 @@ class SeeingIsBelieving
         return '' unless results.has_exception?
         exception = results.exception
         output = "\n"
-        output << CommentFormatter.new(0, "# ~> ", exception.class_name, options).call << "\n"
+        output << CommentFormatter.new(0, EXCEPTION_MARKER, exception.class_name, options).call << "\n"
         exception.message.each_line do |line|
-          output << CommentFormatter.new(0, "# ~> ", line.chomp, options).call << "\n"
+          output << CommentFormatter.new(0, EXCEPTION_MARKER, line.chomp, options).call << "\n"
         end
-        output << "# ~>\n"
+        output << EXCEPTION_MARKER.sub(/\s+$/, '') << "\n"
         exception.backtrace.each do |line|
-          output << CommentFormatter.new(0, "# ~> ", line.chomp, options).call << "\n"
+          output << CommentFormatter.new(0, EXCEPTION_MARKER, line.chomp, options).call << "\n"
         end
         output
       end

data/lib/seeing_is_believing/binary/clean_body.rb

@@ -18,7 +18,9 @@ class SeeingIsBelieving
       end
 
       def call
-        buffer, parser, rewriter, ast, comments = ParserHelpers.initialize_parser code, 'strip_comments'
+        buffer, parser, rewriter = ParserHelpers.initialize_parser code, 'strip_comments'
+        comments                 = ParserHelpers.comments_from parser, buffer
+
         removed_comments      = { result: [], exception: [], stdout: [], stderr: [] }
 
         comments.each do |comment|
@@ -76,7 +78,7 @@ class SeeingIsBelieving
         current_chunk     = 0
         last_line_seen    = -100
         chunks_to_comment = comments.chunk do |comment|
-          line, col = buffer.decompose_position comment.location.begin_pos
+          line = comment.location.begin_pos.line
           if last_line_seen.next == line
             last_line_seen = line
             current_chunk

data/lib/seeing_is_believing/binary/commentable_lines.rb

@@ -2,6 +2,8 @@ require 'seeing_is_believing/parser_helpers'
 
 class SeeingIsBelieving
   class Binary
+
+    # could possibly be sped up by just reflecting on the tokens instead of the whole ast
     class CommentableLines
 
       include ParserHelpers
@@ -12,8 +14,8 @@ class SeeingIsBelieving
 
       def initialize(code)
         self.code = code
-        self.buffer, self.parser, self.rewriter, self.root, self.comments =
-          initialize_parser(code, 'strip_comments')
+        self.buffer, self.parser, self.rewriter = initialize_parser(code, 'finding_commentable_lines')
+        self.root, self.comments = parser.parse_with_comments(buffer)
       end
 
       def call

data/lib/seeing_is_believing/binary/parse_args.rb

@@ -2,6 +2,7 @@
 
 require 'stringio'
 require 'seeing_is_believing/version'
+require 'seeing_is_believing/binary'
 require 'seeing_is_believing/debugger'
 require 'seeing_is_believing/binary/align_file'
 require 'seeing_is_believing/binary/align_line'
@@ -145,7 +146,7 @@ Usage: seeing_is_believing [options] [filename]
   -l, --start-line n            # line number to begin showing results on
   -L, --end-line n              # line number to stop showing results on
   -d, --line-length n           # max length of the entire line (only truncates results, not source lines)
-  -D, --result-length n         # max length of the portion after the "# => "
+  -D, --result-length n         # max length of the portion after the "#{VALUE_MARKER}"
   -s, --alignment-strategy name # select the alignment strategy:
                                   chunk (DEFAULT) =>  each chunk of code is at the same alignment
                                   file            =>  the entire file is at the same alignment
@@ -168,53 +169,53 @@ Examples: A few examples, for a more comprehensive set of examples, check out fe
 
   Run the file f.rb
     $ echo __FILE__ > f.rb; seeing_is_believing f.rb
-    __FILE__  # => "f.rb"
+    __FILE__  #{VALUE_MARKER}"f.rb"
 
   Aligning comments
     $ ruby -e 'puts "123\\n4\\n\\n567890"' > f.rb
 
 
     $ seeing_is_believing f.rb -s line
-    123  # => 123
-    4  # => 4
+    123  #{VALUE_MARKER}123
+    4  #{VALUE_MARKER}4
 
-    567890  # => 567890
+    567890  #{VALUE_MARKER}567890
 
 
     $ seeing_is_believing f.rb -s chunk
-    123  # => 123
-    4    # => 4
+    123  #{VALUE_MARKER}123
+    4    #{VALUE_MARKER}4
 
-    567890  # => 567890
+    567890  #{VALUE_MARKER}567890
 
 
     $ seeing_is_believing f.rb -s file
-    123     # => 123
-    4       # => 4
+    123     #{VALUE_MARKER}123
+    4       #{VALUE_MARKER}4
 
-    567890  # => 567890
+    567890  #{VALUE_MARKER}567890
 
   Run against standard input
     $ echo '3.times { |i| puts i }' | seeing_is_believing
-    2.times { |i| puts i }  # => 2
+    2.times { |i| puts i }  #{VALUE_MARKER}2
 
-    # >> 0
-    # >> 1
+    #{STDOUT_MARKER}0
+    #{STDOUT_MARKER}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
+    pp [[*1..15],[*15..30]]; nil  #{VALUE_MARKER}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]]
+    #{STDOUT_MARKER}[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    #{STDOUT_MARKER} [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
+    2 #{VALUE_MARKER}2
     3
 
   Set a timeout (especially useful if running via an editor)
@@ -223,11 +224,11 @@ Examples: A few examples, for a more comprehensive set of examples, check out fe
 
   Set the encoding to utf-8
     $ seeing_is_believing -Ku -e '"⛄ "'
-    "⛄ "  # => "⛄ "
+    "⛄ "  #{VALUE_MARKER}"⛄ "
 
   The exit status will be 1 if the error is displayable inline
     $ seeing_is_believing -e 'raise "omg"'; echo $?
-    raise "omg"  # ~> RuntimeError: omg
+    raise "omg"  #{EXCEPTION_MARKER}RuntimeError: omg
     1
 
   The exit status will be 2 if the error is not displayable
@@ -236,15 +237,15 @@ Examples: A few examples, for a more comprehensive set of examples, check out fe
     2
 
   Run with previous output
-    $ echo "1+1  # => old-value" | seeing_is_believing
-    1+1  # => 2
+    $ echo "1+1  #{VALUE_MARKER}old-value" | seeing_is_believing
+    1+1  #{VALUE_MARKER}2
 
-    $ echo "1+1  # => old-value" | seeing_is_believing --clean
+    $ echo "1+1  #{VALUE_MARKER}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
+    123  #{VALUE_MARKER}123
 
 HELP_SCREEN
     end

data/lib/seeing_is_believing/binary/rewrite_comments.rb

@@ -4,7 +4,8 @@ class SeeingIsBelieving
   class Binary
     module RewriteComments
       def self.call(code, &mapping)
-        buffer, parser, rewriter, ast, comments = ParserHelpers.initialize_parser code, 'strip_comments'
+        buffer, parser, rewriter = ParserHelpers.initialize_parser code, 'rewrite_comments'
+        ast, comments  = parser.parse_with_comments buffer
 
         comments.each do |comment|
           next unless comment.type == :inline

data/lib/seeing_is_believing/parser_helpers.rb

@@ -1,15 +1,36 @@
 require 'parser/current'
 class SeeingIsBelieving
   module ParserHelpers
+
+    # override #process so it does not raise an error on
+    # fatal parsings (we want to keep going if possible,
+    # this allows us to find comments in syntactically invalid files
+    class NullDiagnostics < Parser::Diagnostic::Engine
+      def process(*)
+        # no op
+      end
+    end
+
     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]
+      buffer                             = Parser::Source::Buffer.new(name)
+      buffer.source                      = code
+
+      builder                            = Parser::Builders::Default.new
+      builder.emit_file_line_as_literals = false
+
+      parser                             = Parser::CurrentRuby.new builder
+      rewriter                           = Parser::Source::Rewriter.new buffer
+
+      [buffer, parser, rewriter]
+    end
+
+    # useful b/c it can find comments even in syntactically invalid code
+    def comments_from(parser, buffer)
+      parser.instance_variable_set(:@diagnostics, NullDiagnostics.new) # seems really fucking risky
+      success, comments, tokens, * = parser.tokenize buffer            # experimentally, seems to be what these things return
+      comments
     end
 
     # this is the scardest fucking method I think I've ever written.
@@ -21,7 +42,6 @@ class SeeingIsBelieving
       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

data/lib/seeing_is_believing/version.rb

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

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -45,7 +45,8 @@ 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, _, self.rewriter, self.root, _ = initialize_parser(program, 'program-without-annotations')
+      self.buffer, parser, self.rewriter = initialize_parser(program, 'program-without-annotations')
+      self.root        = parser.parse buffer
       self.wrappings   = {}
     rescue Parser::SyntaxError => e
       raise ::SyntaxError, e.message
@@ -58,8 +59,15 @@ class SeeingIsBelieving
         if root # file may be empty
           rewriter.insert_before root.location.expression, before_all
 
-          wrappings.each do |line_num, (range, last_col)|
+
+          wrappings.each do |line_num, (range, last_col, meta)|
             rewriter.insert_before range, before_each.call(line_num)
+            if meta == :wrap_in_braces
+              rewriter.insert_before range, '{'
+              rewriter.insert_after  range,  '}'
+            elsif meta == :total_fucking_failure
+              rewriter.replace range,  '.....TOTAL FUCKING FAILURE!.....'
+            end
             rewriter.insert_after  range, after_each.call(line_num)
           end
 
@@ -78,12 +86,12 @@ class SeeingIsBelieving
 
     attr_accessor :program, :before_all, :after_all, :before_each, :after_each, :buffer, :root, :rewriter, :wrappings
 
-    def add_to_wrappings(range_or_ast)
+    def add_to_wrappings(range_or_ast, meta=nil)
       range = range_or_ast
       range = range_or_ast.location.expression if range.kind_of? ::AST::Node
       line, col = buffer.decompose_position range.end_pos
-      _, prev_col = wrappings[line]
-      wrappings[line] = (!wrappings[line] || prev_col < col ? [range, col] : wrappings[line] )
+      _, prev_col, _ = wrappings[line]
+      wrappings[line] = (!wrappings[line] || prev_col < col ? [range, col, meta] : wrappings[line] )
     end
 
     def add_children(ast, omit_first = false)
@@ -228,7 +236,10 @@ class SeeingIsBelieving
 
         begin_pos = ast.location.expression.begin_pos
         range     = Parser::Source::Range.new(buffer, begin_pos, end_pos)
-        add_to_wrappings range
+
+        meta = nil
+        meta = :total_fucking_failure if message == :__TOTAL_FUCKING_FAILURE__
+        add_to_wrappings range, meta
         add_children ast
       when :begin
         last_child = ast.children.last
@@ -242,6 +253,13 @@ class SeeingIsBelieving
         add_children ast
       when :str, :dstr, :xstr, :regexp
         add_to_wrappings heredoc_hack ast
+
+      when :hash
+        meta = :wrap_in_braces
+        meta = nil if ast.location.begin
+        add_to_wrappings ast, meta
+        add_children ast
+
       else
         add_to_wrappings ast
         add_children ast

data/spec/seeing_is_believing_spec.rb

@@ -125,17 +125,17 @@ describe SeeingIsBelieving do
     values_for("-> {  \n return 1          \n }.call"        ).should == [[], ['1'], ['1']]
     values_for("-> { return 1 }.call"                        ).should == [['1']]
 
-    pending "we'd like this to record 1 and nil, but currently we dont' differentiate between inline and multiline if statements" do
+    pending "would be really cool if this would record 1 and nil, but it probably won't ever happen." do
+      # Currently we dont' differentiate between inline and multiline if statements,
+      # also, we can't wrap the whole statement since it's void value, which means we'd have to introduce
+      # the idea of multiple wrappings for the same line, which I just don't care enough about to consider
       values_for("def meth \n return 1 if true  \n end \n meth").should == [[], ['1'], [], ['1']]   # records true instead of 1
       values_for("def meth \n return 1 if false \n end \n meth").should == [[], ['nil'], [], ['nil']] # records false instead of nil
     end
   end
 
   it 'does not try to record the keyword next' do
-    # tbh, I don't even really know what I want in this case. Maybe record nothing since there is no arg to next?
-    pending 'broken because of misordering in the rewriter' do
-      values_for("(1..2).each do |i|\nnext if i == 1\ni\nend").should == [['1..2'], [], ['true', 'false'], ['1..2']]
-    end
+    values_for("(1..2).each do |i|\nnext if i == 1\ni\nend").should == [['1..2'], ['true', 'false'], ['2'], ['1..2']]
   end
 
   it 'does not try to record the keyword redo' do
@@ -152,25 +152,28 @@ describe SeeingIsBelieving do
   end
 
   it 'does not try to record the keyword retry' do
-    pending 'uhhh, what do I want here?' do
-      values_for(<<-DOC).should == [[], [], [], ['nil']]
-        def meth
-        rescue
-          retry
-        end
-      DOC
-    end
+    values_for(<<-DOC).should == [[], [], [], [], ['nil']]
+      def meth
+      rescue
+        retry
+      end
+      meth
+    DOC
   end
 
   it 'does not try to record the keyword retry' do
-    pending 'uhhh, what do I want here?' do
-      values_for(<<-DOC).should == [[], ['0'], [], ['nil']]
-        (0..2).each do |n|
-          n
-          break
-        end
-      DOC
-    end
+    values_for(<<-DOC).should == [['0..2'], ['0'], [], ['nil']]
+      (0..2).each do |n|
+        n
+        break
+      end
+    DOC
+    values_for(<<-DOC).should == [['0..2'], ['0'], ['10'], ['10']]
+      (0..2).each do |n|
+        n
+        break 10
+      end
+    DOC
   end
 
   it 'does not affect its environment' do
@@ -319,6 +322,22 @@ describe SeeingIsBelieving do
     end
   end
 
+  it 'does not record BEGIN and END', not_implemented: true do
+    expect { invoke <<-CODE }.to_not raise_error
+    puts 1
+    BEGIN {
+      puts "begin code"
+      some_var = 2
+    }
+    puts 3
+    END {
+      puts "end code"
+      puts some_var
+    }
+    puts 4
+    CODE
+  end
+
   context 'when given a debugger' do
     let(:stream)   { StringIO.new }
     let(:debugger) { SeeingIsBelieving::Debugger.new stream: stream }

data/spec/wrap_expressions_spec.rb

@@ -1,9 +1,5 @@
 require 'seeing_is_believing/wrap_expressions'
 
-# eventually make this not wrap BEGIN and END
-# but for now, leave it b/c it's convenient to be able to make it blow up
-# Probably replace this with some macro like __INVALID_SYNTAX__ that blows it up :)
-
 describe SeeingIsBelieving::WrapExpressions do
   def wrap(code)
     described_class.call code,
@@ -15,6 +11,10 @@ describe SeeingIsBelieving::WrapExpressions do
     expect { wrap '+' }.to raise_error SyntaxError
   end
 
+  it 'can inject syntax errors with __TOTAL_FUCKING_FAILURE__' do
+    wrap('__TOTAL_FUCKING_FAILURE__').should == '<.....TOTAL FUCKING FAILURE!.....>'
+  end
+
   describe 'wrapping the body' do
     let(:options) { { before_all: "[",
                       after_all:  "]",
@@ -514,6 +514,10 @@ describe SeeingIsBelieving::WrapExpressions do
       wrap("{\n1 => 2}").should == "<{\n1 => 2}>"
       wrap("{\n1 => 2,\n:abc => 3,\ndef: 4\n}").should == "<{\n1 => <2>,\n:abc => <3>,\ndef: <4>\n}>"
     end
+
+    it 'wraps explicit braces around recorded in method invocations' do
+      wrap("a(\nb: 1, c: 2\n)").should == "<a(\n<{b: 1, c: 2}>\n)>"
+    end
   end
 
   describe 'array literals' do
@@ -761,4 +765,32 @@ describe SeeingIsBelieving::WrapExpressions do
       end
     end
   end
+
+  describe 'BEGIN/END' do
+    # not implemented b/c we cannot wrap around these either.
+    # So what does it mean to wrap around?
+    # mabe this?
+    #   1
+    #   BEGIN {}
+    #   2
+    #   END {}
+    #   3
+    #
+    # becomes
+    #   BEGIN {}
+    #   END {}
+    #   [<1>
+    #   <2>
+    #   <3>]
+    #
+    # idk, but then we also need to deal with the fact that we're changing result of __LINE__
+    # which we could do with some meta, just replacing it with the literal when we parse it
+    # but still, moving this out of here will be really annoying, and no one is going to use it, so fuck it
+    it 'does not record them', not_implemented: true do
+      wrap("BEGIN {}").should == "BEGIN {}"
+      wrap("END {}").should == "END {}"
+      wrap("BEGIN {\n123\n}").should == "BEGIN {\n<123>\n}"
+      wrap("END {\n123\n}").should == "END {\n<123>\n}"
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta3
+  version: 2.0.0
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-14 00:00:00.000000000 Z
+date: 2013-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -166,9 +166,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: seeing_is_believing
 rubygems_version: 2.0.5
@@ -192,4 +192,3 @@ test_files:
 - spec/line_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/wrap_expressions_spec.rb
-has_rdoc: