seeing_is_believing 0.0.24 → 0.0.26

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dda86a6b926231e08234e6a6a7c7fde07d650888
+  data.tar.gz: 39ab6eff76179f074c4382d5ffef3d49683bc624
+SHA512:
+  metadata.gz: c4ad0cc0e416f1c1e01b9650a6e5a2143dbeccb4c668478b179e2a3898b0b9655c5b920b334f69e7bce7d748b4204930ab9a5d376b51dc49b727399b40e6c875
+  data.tar.gz: c27f2c5220c0a9e6991384de68dc4c9e3de44f7de954356311fae9989b45d531240f40be3cb6ffca5536820967efd2123aa7353ec2f1cc474566120b634bf311

data/Readme.md

@@ -146,8 +146,14 @@ Known Issues
 Todo
 ====
 
+* Make a Lines class which is a collection of lines, responsible for managing the trailing newlines in Binary::PrintResultsNextToLines and SeeingIsBelieving/ExpressionList
+* 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
 * 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
+* print exceptions at the end of the file, too
+
+
 
 License
 =======

data/bin/seeing_is_believing

@@ -3,4 +3,4 @@
 $LOAD_PATH.unshift File.expand_path '../../lib', __FILE__
 
 require 'seeing_is_believing/binary'
-exit SeeingIsBelieving::Binary.new(ARGV, $stdin, $stdout, $stderr).exitstatus
+exit SeeingIsBelieving::Binary.new(ARGV, $stdin, $stdout, $stderr).call

data/features/flags.feature

@@ -420,20 +420,32 @@ Feature: Using flags
     When I run "seeing_is_believing --inherit-exit-status exit_status_in_at_exit_block.rb"
     Then the exit status is 10
 
-  @wip
+  # after making this use the parser instead of regexes, add a test showing that the line `"1 # =>"` does not get updated
   Scenario: --xmpfilter-style
     Given the file "magic_comments.rb":
     """
-    1# =>
-    1    # =>
+    1+1# =>
+    2+2    # => 10
+    "a
+     b" # =>
     1
+    "omg"
+    # =>
+    "omg2"
+    # => "not omg2"
     """
     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+1# => 2
+    2+2    # => 4
+    "a
+     b" # => "a\n b"
     1
+    "omg"
+    # => "omg"
+    "omg2"
+    # => "omg2"
     """

data/features/regression.feature

@@ -60,3 +60,43 @@ Feature:
     m             # => 1
     """
 
+  Scenario: comments aren't updated with values
+    Given the file "comments_arent_updated_with_values.rb":
+    """
+    1 # some comment
+    2 # some other comment
+    """
+    When I run "seeing_is_believing comments_arent_updated_with_values.rb"
+    Then stdout is:
+    """
+    1 # some comment
+    2 # some other comment
+    """
+
+  # NOTE: Don't change the body of this file, it's nondeterministic
+  # I have no idea why this particular string fucks Parser up, but other similar ones don't
+  # We can probably remove this once parser reaches 2.0.0, they've fixed this bug now.
+  Scenario: Parser correctly identify comments
+    Given the file "parser_bug.rb" "Class # whatever"
+    When I run "seeing_is_believing parser_bug.rb"
+    Then stdout is "Class # whatever"
+    Then stderr is empty
+    And the exit status is 0
+
+
+  Scenario: Modifying output doesn't fuck it up when passing it back again as input
+    Given the file "modified_result.rb":
+    """
+    1
+    # >> stdout
+    2
+    # !> stderr
+    __END__
+    """
+    When I run "seeing_is_believing modified_result.rb"
+    Then stdout is:
+    """
+    1  # => 1
+    2  # => 2
+    __END__
+    """

data/lib/seeing_is_believing/binary/arg_parser.rb

@@ -67,19 +67,21 @@ class SeeingIsBelieving
 
       def options
         @options ||= {
-          version:            false,
-          clean:              false,
-          program:            nil,
-          filename:           nil,
-          start_line:         1,
-          line_length:        Float::INFINITY,
-          end_line:           Float::INFINITY,
-          result_length:      Float::INFINITY,
-          timeout:            0, # timeout lib treats this as infinity
-          errors:             [],
-          require:            [],
-          load_path:          [],
-          alignment_strategy: AlignChunk,
+          version:             false,
+          clean:               false,
+          xmpfilter_style:     false,
+          inherit_exit_status: false,
+          program:             nil,
+          filename:            nil,
+          start_line:          1,
+          line_length:         Float::INFINITY,
+          end_line:            Float::INFINITY,
+          result_length:       Float::INFINITY,
+          timeout:             0, # timeout lib treats this as infinity
+          errors:              [],
+          require:             [],
+          load_path:           [],
+          alignment_strategy:  AlignChunk,
         }
       end
 
@@ -132,24 +134,25 @@ Usage: seeing_is_believing [options] [filename]
 
   If no filename is provided, the binary will read the program from standard input.
 
-  -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 "# => "
-  -s, --alignment-strategy  # select the alignment strategy:
-                              chunk (DEFAULT) =>  each chunk of code is at the same alignment
-                              file            =>  the entire file is at the same alignment
-                              line            =>  each line is at its own alignment
-  -t, --timeout n           # timeout limit in seconds when evaluating source file (ex. -t 0.3 or -t 3)
-  -I, --load-path dir       # a dir that should be added to the $LOAD_PATH
-  -r, --require file        # additional files to be required before running the program
-  -e, --program program     # Pass the program to execute as an argument
-  -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
+  -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 "# => "
+  -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
+                                  line            =>  each line is at its own alignment
+  -t, --timeout n               # timeout limit in seconds when evaluating source file (ex. -t 0.3 or -t 3)
+  -I, --load-path dir           # a dir that should be added to the $LOAD_PATH
+  -r, --require file            # additional files to be required before running the program
+  -e, --program program         # Pass the program to execute as an argument
+  -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
+  -x, --xmpfilter-style         # annotate marked lines instead of every line
+  -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
     end
   end

data/lib/seeing_is_believing/binary/print_results_next_to_lines.rb

@@ -2,6 +2,17 @@ require 'seeing_is_believing/queue'
 require 'seeing_is_believing/has_exception'
 require 'seeing_is_believing/binary/line_formatter'
 
+# I think there is a bug where with xmpfilter_style set,
+# the exceptions won't be shown. But it's not totally clear
+# how to show them with this option set, anyway.
+# probably do what xmpfilter does and print them at the bottom
+# of the file (probably do this regardless of whether xmpfilter_style
+# is set)
+#
+# Would also be nice to support
+#     1 + 1
+#     # => 2
+# style updates like xmpfilter does
 
 class SeeingIsBelieving
   class Binary
@@ -15,8 +26,8 @@ class SeeingIsBelieving
 
       def self.remove_previous_output_from(string)
         string.gsub(/\s+(#{EXCEPTION_PREFIX}|#{RESULT_PREFIX}).*?$/, '')
-              .gsub(/\n?(^#{STDOUT_PREFIX}[^\n]*\r?\n?)+/m,          '')
-              .gsub(/\n?(^#{STDERR_PREFIX}[^\n]*\r?\n?)+/m,          '')
+              .gsub(/(^\n)?(^#{STDOUT_PREFIX}[^\n]*\r?\n?)+/m,       '')
+              .gsub(/(^\n)?(^#{STDERR_PREFIX}[^\n]*\r?\n?)+/m,       '')
       end
 
 
@@ -27,14 +38,23 @@ class SeeingIsBelieving
       method_from_options :filename, nil
       method_from_options :start_line
       method_from_options :end_line
-      method_from_options :line_length,   Float::INFINITY
-      method_from_options :result_length, Float::INFINITY
+      method_from_options :line_length,    Float::INFINITY
+      method_from_options :result_length,  Float::INFINITY
+      method_from_options :xmpfilter_style
 
-      def initialize(body, file_result, options={})
-        self.body               = body
+      attr_accessor :file_result
+      def initialize(body, options={})
+        cleaned_body            = self.class.remove_previous_output_from body
         self.options            = options
-        self.file_result        = file_result
-        self.alignment_strategy = options[:alignment_strategy].new body, start_line, end_line
+        self.body               = (xmpfilter_style ? body : cleaned_body)
+        self.file_result        = 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]
+        self.alignment_strategy = options[:alignment_strategy].new cleaned_body, start_line, end_line
       end
 
       def new_body
@@ -42,44 +62,51 @@ class SeeingIsBelieving
       end
 
       def call
-        add_each_line_until_start_or_data_segment
-        add_lines_with_results_until_end_or_data_segment
-        add_lines_until_data_segment
-        add_stdout
-        add_stderr
-        add_remaining_lines
-        return new_body
+        @printed_program ||= begin
+          # can we put the call to chomp into the line_queue initialization code?
+          line_queue.until { |line, line_number| SyntaxAnalyzer.begins_data_segment?(line.chomp) }
+                    .each  { |line, line_number| add_line line, line_number }
+          add_stdout
+          add_stderr
+          add_remaining_lines
+          new_body
+        end
       end
 
       private
 
-      attr_accessor :body, :file_result, :options, :alignment_strategy
-
-      def add_each_line_until_start_or_data_segment
-        line_queue.until { |line, line_number| line_number == start_line || start_of_data_segment?(line) }
-                  .each  { |line, line_number| new_body << line }
-      end
-
-      def add_lines_with_results_until_end_or_data_segment
-        line_queue.until { |line, line_number| end_line < line_number || start_of_data_segment?(line) }
-                  .each  { |line, line_number| new_body << format_line(line.chomp, line_number, file_result[line_number]) }
-      end
+      attr_accessor :body, :options, :alignment_strategy
 
-      def add_lines_until_data_segment
-        line_queue.until { |line, line_number| start_of_data_segment?(line) }
-                  .each  { |line, line_number| new_body << line }
+      def line_queue
+        @line_queue ||= Queue.new &body.each_line.with_index(1).to_a.method(:shift)
       end
 
-      def add_remaining_lines
-        line_queue.each { |line, line_number| new_body << line }
+      # if we want to pull this into a strategy
+      # we need to make available:
+      #   file_result, start_line, end_line, alignment_strategy, line_length, result_length
+      def add_line(line, line_number)
+        should_record = should_record? line, line_number
+        if should_record && xmpfilter_style && line.strip =~ /^# =>/
+          new_body << xmpfilter_update(line, file_result[line_number - 1])
+        elsif should_record && xmpfilter_style
+          new_body << xmpfilter_update(line, file_result[line_number])
+        elsif should_record
+          new_body << format_line(line.chomp, line_number, file_result[line_number])
+        else
+          new_body << line
+        end
       end
 
-      def line_queue
-        @line_queue ||= Queue.new &body.each_line.with_index(1).to_a.method(:shift)
+      def should_record?(line, line_number)
+        (start_line <= line_number) &&
+          (line_number <= end_line) &&
+          (xmpfilter_style ? line =~ /# =>/ : # technically you could fuck this up with a line like "# =>", should later delegate to syntax analyzer
+                             !SyntaxAnalyzer.ends_in_comment?(line))
       end
 
-      def start_of_data_segment?(line)
-        SyntaxAnalyzer.begins_data_segment?(line.chomp)
+      # again, this is too naive, should actually parse the comments and update them
+      def xmpfilter_update(line, line_results)
+        line.gsub /# =>.*?$/, "# => #{line_results.join ', '}"
       end
 
       def add_stdout
@@ -98,6 +125,10 @@ class SeeingIsBelieving
         end
       end
 
+      def add_remaining_lines
+        line_queue.each { |line, line_number| new_body << line }
+      end
+
       def format_line(line, line_number, line_results)
         options = options().merge pad_to: alignment_strategy.line_length_for(line_number)
         formatted_line = if line_results.has_exception?

data/lib/seeing_is_believing/binary.rb

@@ -20,23 +20,26 @@ class SeeingIsBelieving
     end
 
     def call
-      @exitstatus ||= if    flags_have_errors?          then print_errors           ; NONDISPLAYABLE_ERROR_STATUS
-                      elsif should_print_help?          then print_help             ; SUCCESS_STATUS
-                      elsif should_print_version?       then print_version          ; SUCCESS_STATUS
-                      elsif has_filename? && file_dne?  then print_file_dne         ; NONDISPLAYABLE_ERROR_STATUS
-                      elsif should_clean?               then print_cleaned_program  ; SUCCESS_STATUS
-                      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          ; program_exit_status
-                      end
+      @exitstatus ||= begin
+        parse_flags
+
+        if    flags_have_errors?                    then print_errors           ; NONDISPLAYABLE_ERROR_STATUS
+        elsif should_print_help?                    then print_help             ; SUCCESS_STATUS
+        elsif should_print_version?                 then print_version          ; SUCCESS_STATUS
+        elsif has_filename? && file_dne?            then print_file_dne         ; NONDISPLAYABLE_ERROR_STATUS
+        elsif should_clean?                         then print_cleaned_program  ; SUCCESS_STATUS
+        elsif invalid_syntax?                       then print_syntax_error     ; NONDISPLAYABLE_ERROR_STATUS
+        elsif (evaluate_program; program_timedout?) then print_timeout_error    ; NONDISPLAYABLE_ERROR_STATUS
+        elsif something_blew_up?                    then print_unexpected_error ; NONDISPLAYABLE_ERROR_STATUS
+        else                                             print_program          ; program_exit_status
+        end
+      end
     end
 
-    # uhm, this is dumb
-    alias exitstatus call
-
     private
 
+    attr_accessor :flags, :interpolated_program
+
     def program_exit_status
       if flags[:inherit_exit_status]
         results.exitstatus
@@ -47,12 +50,25 @@ class SeeingIsBelieving
       end
     end
 
+    def parse_flags
+      self.flags = ArgParser.parse argv
+    end
+
     def has_filename?
       flags[:filename]
     end
 
+    def evaluate_program
+      self.interpolated_program = printer.call
+    rescue Timeout::Error
+      self.timeout_error = true
+    rescue Exception
+      self.unexpected_exception = $!
+    end
+
+    # could we make this more obvious? I'd like to to be clear from #call
+    # that this is when the program gets evaluated
     def program_timedout?
-      results
       timeout_error
     end
 
@@ -60,23 +76,8 @@ class SeeingIsBelieving
       stderr.puts "Timeout Error after #{@flags[:timeout]} seconds!"
     end
 
-    def cleaned_body
-      @body ||= PrintResultsNextToLines.remove_previous_output_from \
-        flags[:program] || (file_is_on_stdin? && stdin.read) || File.read(flags[:filename])
-    end
-
-    def results
-      @results ||= SeeingIsBelieving.call cleaned_body,
-                                          filename:  (flags[:as] || flags[:filename]),
-                                          require:   flags[:require],
-                                          load_path: flags[:load_path],
-                                          encoding:  flags[:encoding],
-                                          stdin:     (file_is_on_stdin? ? '' : stdin),
-                                          timeout:   flags[:timeout]
-    rescue Timeout::Error
-      self.timeout_error = true
-    rescue Exception
-      self.unexpected_exception = $!
+    def body
+      @body ||= (flags[:program] || (file_is_on_stdin? && stdin.read) || File.read(flags[:filename]))
     end
 
     def something_blew_up?
@@ -88,11 +89,11 @@ class SeeingIsBelieving
     end
 
     def printer
-      @printer ||= PrintResultsNextToLines.new cleaned_body, results, flags
+      @printer ||= PrintResultsNextToLines.new body, flags.merge(stdin: (file_is_on_stdin? ? '' : stdin))
     end
 
-    def flags
-      @flags ||= ArgParser.parse argv
+    def results
+      printer.file_result
     end
 
     def flags_have_errors?
@@ -132,11 +133,11 @@ class SeeingIsBelieving
     end
 
     def print_program
-      stdout.puts printer.call
+      stdout.puts interpolated_program
     end
 
     def syntax_error_notice
-      out, err, syntax_status = Open3.capture3 'ruby', '-c', stdin_data: cleaned_body
+      out, err, syntax_status = Open3.capture3 'ruby', '-c', stdin_data: body
       return err unless syntax_status.success?
     end
 
@@ -153,7 +154,7 @@ class SeeingIsBelieving
     end
 
     def print_cleaned_program
-      stdout.print cleaned_body
+      stdout.print PrintResultsNextToLines.remove_previous_output_from body
     end
   end
 end

data/lib/seeing_is_believing/expression_list.rb

@@ -26,9 +26,8 @@ class SeeingIsBelieving
     def call
       offset, expressions, expression = 0, [], nil
       begin
-        pending_expression = generate
+        pending_expression = generate(expressions)
         debug { "GENERATED: #{pending_expression.expression.inspect}, ADDING IT TO #{inspected_expressions expressions}" }
-        expressions << pending_expression
 
         expression = reduce expressions, offset unless next_line_modifies_current?
 
@@ -41,10 +40,15 @@ class SeeingIsBelieving
 
     attr_accessor :debug_stream, :should_debug, :get_next_line, :peek_next_line, :on_complete, :expressions
 
-    def generate
+    def generate(expressions)
       expression = get_next_line.call
       raise SyntaxError unless expression
-      PendingExpression.new(expression, [])
+      if expressions.last && SyntaxAnalyzer.unfinished_here_doc?(expressions.last.expression)
+        expressions.last.expression << "\n" << expression # more stupid \n -.-
+      else
+        expressions << PendingExpression.new(expression, [])
+      end
+      expressions.last
     end
 
     def next_line_modifies_current?

data/lib/seeing_is_believing/remove_inline_comments.rb

@@ -0,0 +1,22 @@
+require 'parser/current'
+
+class SeeingIsBelieving
+  module RemoveInlineComments
+    extend self
+
+    def self.call(code)
+      remove_inline_comments code
+    end
+
+    def remove_inline_comments(code)
+      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)
+      comments.select { |comment| comment.type == :inline }
+              .each   { |comment| rewriter.remove comment.location }
+      rewriter.process
+    end
+  end
+end

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -162,7 +162,7 @@ class SeeingIsBelieving
       ast = Parser::CurrentRuby.parse(code_or_ast) if code_or_ast.kind_of? String
 
       case ast && ast.type
-      when :begin, :resbody
+      when :begin, :kwbegin, :resbody # begin and kwbegin should be the same thing, but it changed in parser 1.4.1 to 2.0.0, so just adding them both for safety
         void_value_expression?(ast.children[-1])
       when :rescue, :ensure
         ast.children.any? { |child| void_value_expression? child }
@@ -182,6 +182,11 @@ class SeeingIsBelieving
       instance.has_heredoc? && code.scan("\n").size.next <= instance.here_doc_last_line_number
     end
 
+    def self.unfinished_here_doc?(code)
+      instance = parsed code
+      instance.heredocs.any? { |heredoc| heredoc.size == 1 }
+    end
+
     def heredocs
       @heredocs ||= []
     end

data/lib/seeing_is_believing/version.rb

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

data/lib/seeing_is_believing.rb

@@ -6,6 +6,7 @@ require 'seeing_is_believing/queue'
 require 'seeing_is_believing/result'
 require 'seeing_is_believing/version'
 require 'seeing_is_believing/expression_list'
+require 'seeing_is_believing/remove_inline_comments'
 require 'seeing_is_believing/evaluate_by_moving_files'
 
 # might not work on windows b/c of assumptions about line ends
@@ -37,6 +38,7 @@ class SeeingIsBelieving
     @memoized_result ||= begin
       leading_comments = ''
 
+
       # extract leading comments (e.g. encoding) so they don't get wrapped in begin/rescue/end
       while SyntaxAnalyzer.line_is_comment?(next_line_queue.peek)
         leading_comments << next_line_queue.dequeue << "\n"
@@ -83,7 +85,9 @@ class SeeingIsBelieving
     @expression_list ||= ExpressionList.new get_next_line:  lambda { next_line_queue.dequeue },
                                             peek_next_line: lambda { next_line_queue.peek },
                                             on_complete:    lambda { |line, children, completions, offset|
-                                              expression = [line, *children, *completions].map(&:chomp).join("\n")
+                                              expression = RemoveInlineComments.call \
+                                                [line, *children, *completions].map(&:chomp).join("\n")
+
                                               if do_not_record? expression
                                                 expression + "\n"
                                               else
@@ -141,6 +145,7 @@ class SeeingIsBelieving
     @next_line_queue ||= Queue.new { (line = stream.gets) && line.chomp }
   end
 
+  # eh? -.^ (can't we pull the rest of this out of the queue instead of breaking encapsulation?)
   def the_rest_of_the_stream
     next_line_queue.dequeue << "\n" << stream.read
   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",   "~> 1.4"
+  s.add_dependency             "parser",   "~> 2.0.0.beta9"
 
   s.add_development_dependency "haiti",    "~> 0.0.3"
   s.add_development_dependency "rake",     "~> 10.0.3"

data/spec/seeing_is_believing_spec.rb

@@ -107,12 +107,6 @@ describe SeeingIsBelieving do
     # values_for("<<-HEREDOC\n1\nHEREDOC").should == [[], [], ['"\n1\n"']]
   end
 
-  it 'does not record expressions that end in a comment' do
-    values_for("1
-                2 # on internal expression
-                3 # at end of program").should == [['1'], [], []]
-  end
-
   it "does not record expressions that are here docs (only really b/c it's not smart enough)" do
     values_for("<<A\n1\nA").should be_all &:empty?
     values_for(" <<A\n1\nA").should be_all &:empty?
@@ -122,6 +116,27 @@ describe SeeingIsBelieving do
     values_for("def meth\n<<-A\n1\nA\nend").should == [[], [], [], [], ['nil']]
   end
 
+  it 'does not insert code into the middle of heredocs', t:true do
+    invoked = invoke(<<-HEREDOC.gsub(/^      /, ''))
+      puts <<DOC1
+      doc1
+      DOC1
+      puts <<-DOC2
+      doc2
+      DOC2
+      puts <<-DOC3
+      doc3
+        DOC3
+      puts <<DOC4, <<-DOC5
+      doc4
+      DOC4
+      doc5
+      DOC5
+    HEREDOC
+
+    invoked.stdout.should == "doc1\ndoc2\ndoc3\ndoc4\ndoc5\n"
+  end
+
   it 'has no output for empty lines' do
     values_for('').should == [[]]
     values_for('  ').should == [[]]
@@ -189,7 +204,7 @@ describe SeeingIsBelieving do
     DOC
   end
 
-  it 'does not try to record the keyword retry', t2:true do
+  it 'does not try to record the keyword retry' do
     values_for(<<-DOC).should == [[], [], [], ['nil']]
       def meth
       rescue
@@ -290,6 +305,12 @@ describe SeeingIsBelieving do
     invoke('at_exit { exit 121 }').exitstatus.should == 121
   end
 
+  it 'records lines that have comments on them' do
+    values_for('1+1 # comment uno
+                #comment dos
+                3#comment tres').should == [['2'], [], ['3']]
+  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

@@ -35,6 +35,18 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     is_here_doc["a<<b\nb"].should be_false
   end
 
+  it 'knows if the expression is an unfinished heredoc' do
+    is_unfinished_heredoc = lambda { |code| described_class.unfinished_here_doc? code }
+    is_unfinished_heredoc["<<A"].should be_true
+    is_unfinished_heredoc["puts <<A, <<B\na\nA"].should be_true
+    is_unfinished_heredoc["<<-A\n"].should be_true
+
+    is_unfinished_heredoc["puts <<A\na\nA"].should be_false
+    is_unfinished_heredoc["puts <<-A\na\nA"].should be_false
+    is_unfinished_heredoc["puts <<-A\na\n A"].should be_false
+    is_unfinished_heredoc["puts <<A, <<B\na\nA\nB"].should be_false
+  end
+
   it 'knows if the last line is a comment' do
     is_comment = lambda { |code| described_class.ends_in_comment? code }
 

metadata

@@ -1,112 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.0.24
+  version: 0.0.26
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-21 00:00:00.000000000 Z
+date: 2013-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.4'
-    none: false
-  name: parser
+        version: 2.0.0.beta9
   type: :runtime
   prerelease: false
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.4'
-    none: false
+        version: 2.0.0.beta9
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: haiti
+  requirement: !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
+  version_requirements: !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
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 10.0.3
-    none: false
-  name: rake
   type: :development
   prerelease: false
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 10.0.3
-    none: false
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 2.12.0
-    none: false
-  name: rspec
   type: :development
   prerelease: false
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 2.12.0
-    none: false
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.2.1
-    none: false
-  name: cucumber
   type: :development
   prerelease: false
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.2.1
-    none: false
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: ichannel
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 5.1.1
-    none: false
-  name: ichannel
   type: :development
   prerelease: false
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 5.1.1
-    none: false
 description: Records the results of every line of code in your file (intended to be
   like xmpfilter), inspired by Bret Victor's JavaScript example in his talk "Inventing
   on Principle"
@@ -143,6 +130,7 @@ files:
 - lib/seeing_is_believing/has_exception.rb
 - lib/seeing_is_believing/line.rb
 - lib/seeing_is_believing/queue.rb
+- lib/seeing_is_believing/remove_inline_comments.rb
 - lib/seeing_is_believing/result.rb
 - lib/seeing_is_believing/syntax_analyzer.rb
 - lib/seeing_is_believing/the_matrix.rb
@@ -162,27 +150,26 @@ files:
 homepage: https://github.com/JoshCheek/seeing_is_believing
 licenses:
 - WTFPL
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
 rubyforge_project: seeing_is_believing
-rubygems_version: 1.8.23
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Records results of every line of code in your file
 test_files:
 - features/errors.feature