seeing_is_believing 2.0.0.beta1 → 2.0.0.beta2

data/lib/seeing_is_believing/binary/rewrite_comments.rb

@@ -0,0 +1,42 @@
+require 'parser/current'
+
+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)
+
+        comments.each do |comment|
+          next unless comment.type == :inline
+          # find whitespace
+          last_char                   = comment.location.expression.begin_pos
+          first_char                  = last_char
+          first_char -= 1 while first_char > 0 && buffer.source[first_char-1] =~ /[ \t]/
+          preceeding_whitespace       = buffer.source[first_char...last_char]
+          preceeding_whitespace_range = Parser::Source::Range.new buffer, first_char, last_char
+
+          # find line
+          last_char = first_char
+          first_char -= 1 while first_char > 0 && buffer.source[first_char-1] !~ /[\r\n]/
+          line = buffer.source[first_char...last_char]
+
+          # get results
+          new_whitespace, new_comment = mapping.call(comment.location.line,
+                                                     line,
+                                                     preceeding_whitespace,
+                                                     comment.text)
+
+          # update code
+          rewriter.replace preceeding_whitespace_range, new_whitespace
+          rewriter.replace comment.location.expression, new_comment
+        end
+
+        rewriter.process
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/result.rb

@@ -1,11 +1,9 @@
 require 'seeing_is_believing/line'
 require 'seeing_is_believing/has_exception'
-require 'seeing_is_believing/tracks_line_numbers_seen'
 
 class SeeingIsBelieving
   class Result
     include HasException
-    include TracksLineNumbersSeen
     include Enumerable
 
     attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib
@@ -20,12 +18,7 @@ class SeeingIsBelieving
       stderr && !stderr.empty?
     end
 
-    def initialize
-      @min_line_number = @max_line_number = 1
-    end
-
     def record_result(line_number, value)
-      track_line_number line_number
       results_for(line_number) << value.inspect
       value
     end
@@ -35,7 +28,6 @@ class SeeingIsBelieving
                                                  exception.message,
                                                  exception.backtrace
       self.exception = recorded_exception
-      track_line_number line_number
       results_for(line_number).exception = recorded_exception
     end
 
@@ -44,7 +36,8 @@ class SeeingIsBelieving
     end
 
     def each(&block)
-      (min_line_number..max_line_number).each { |line_number| block.call self[line_number] }
+      max = results.keys.max || 1
+      (1..max).each { |line_number| block.call self[line_number] }
     end
 
     def inspect

data/lib/seeing_is_believing/the_matrix.rb

@@ -9,16 +9,16 @@ STDOUT = $stdout = fake_stdout = StringIO.new
 STDERR = $stderr = fake_stderr = StringIO.new
 
 require 'seeing_is_believing/result'
-$seeing_is_believing_current_result = SeeingIsBelieving::Result.new
+$SiB = SeeingIsBelieving::Result.new
 
 at_exit do
-  $seeing_is_believing_current_result.stdout = fake_stdout.string
-  $seeing_is_believing_current_result.stderr = fake_stderr.string
+  $SiB.stdout = fake_stdout.string
+  $SiB.stderr = fake_stderr.string
 
-  $seeing_is_believing_current_result.exitstatus ||= 0
-  $seeing_is_believing_current_result.exitstatus   = 1         if $!
-  $seeing_is_believing_current_result.exitstatus   = $!.status if $!.kind_of? SystemExit
-  $seeing_is_believing_current_result.bug_in_sib   = $! && ! $!.kind_of?(SystemExit)
+  $SiB.exitstatus ||= 0
+  $SiB.exitstatus   = 1         if $!
+  $SiB.exitstatus   = $!.status if $!.kind_of? SystemExit
+  $SiB.bug_in_sib   = $! && ! $!.kind_of?(SystemExit)
 
-  real_stdout.write YAML.dump $seeing_is_believing_current_result
+  real_stdout.write YAML.dump $SiB
 end

data/lib/seeing_is_believing/version.rb

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

data/lib/seeing_is_believing/{program_rewriter.rb → wrap_expressions.rb}

@@ -1,7 +1,7 @@
 require 'parser/current'
 
 # hack rewriter to apply insertions in stable order
-# until https://github.com/whitequark/parser/pull/102 gets merged in
+# until https://github.com/whitequark/parser/pull/102 gets released
 module Parser
   module Source
     class Rewriter
@@ -30,7 +30,7 @@ end
 # comprehensive list of syntaxes that can come up
 # https://github.com/whitequark/parser/blob/master/doc/AST_FORMAT.md
 class SeeingIsBelieving
-  class ProgramReWriter
+  class WrapExpressions
     def self.call(program, wrappings)
       new(program, wrappings).call
     end
@@ -62,7 +62,11 @@ class SeeingIsBelieving
             rewriter.insert_after  range, after_each.call(line_num)
           end
 
-          rewriter.insert_after root.location.expression, after_all
+          # another stupid hack to get around a heredoc at the end of the document
+          # hopefully we can remove this after next version of Parser is released
+          last_index, (range, col) = wrappings.max_by(&:first)
+          range ||= root.location.expression
+          rewriter.insert_after range, after_all
         end
 
         rewriter.process
@@ -110,6 +114,10 @@ class SeeingIsBelieving
       when :resbody
         exception_type, variable_name, body = ast.children
         find_wrappings body
+      when :array
+        add_to_wrappings ast
+        the_begin = ast.location.begin
+        add_children ast if the_begin && the_begin.source !~ /\A%/
       when :block
         add_to_wrappings ast
 
@@ -140,32 +148,24 @@ class SeeingIsBelieving
         # in the second, there is an implicit Array wrapped around it, with the wrong end_pos,
         # so we must take the end_pos of the last arg
         array = ast.children.last
-        if array.location.expression.source.start_with? '['
+        if array.type != :array # e.g. `a, g = c`
+          add_to_wrappings ast
+          add_to_wrappings ast.children.last
+        elsif array.location.expression.source.start_with? '['
           add_to_wrappings ast
           find_wrappings array
         else
           begin_pos = ast.location.expression.begin_pos
-          end_pos   = heredoc_hack(ast.children.last.children.last).location.expression.end_pos
+          end_pos   = heredoc_hack(array.children.last).location.expression.end_pos
           range     = Parser::Source::Range.new buffer, begin_pos, end_pos
           add_to_wrappings range
           add_children ast.children.last
         end
-      when :lvasgn
+      when :lvasgn, :ivasgn, :gvasgn, :cvasgn, :casgn # local variable, instance variable, global variable, class variable, constant
         # because the RHS can be a heredoc, and parser currently handles heredocs locations incorrectly
         # we must hack around this
 
-        # can have one or two children:
-        #   in a=1 (has children :a, and 1)
-        #   in a,b=1,2 it comes out like:
-        #     (masgn
-        #       (mlhs
-        #         (lvasgn :a) <-- one child
-        #
-        #         (lvasgn :b))
-        #       (array
-        #         (int 1)
-        #         (int 2)))
-        if ast.children.size == 2
+        if ast.children.last.kind_of? ::AST::Node
           begin_pos = ast.location.expression.begin_pos
           end_pos   = heredoc_hack(ast.children.last).location.expression.end_pos
           range     = Parser::Source::Range.new buffer, begin_pos, end_pos
@@ -190,15 +190,20 @@ class SeeingIsBelieving
             end_pos += 1
           end
 
-        # the last arg is not a heredoc, the range of the expression can be trusted
+        elsif heredoc?(target) && last_arg
+          end_pos = last_arg.location.expression.end_pos
+
+        # neither the target, nor the last arg are heredocs, the range of the expression can be trusted
         elsif last_arg
           end_pos = ast.location.expression.end_pos
 
+        # in lambda{}.() the send has no selector, so use the expression
+        # I'm going to ignore the fact that you could define call on a heredoc and do <<HERE.(),
+        elsif !ast.location.selector
+          end_pos = ast.location.expression.end_pos
+
         # there is no last arg, but there are parens, find the closing paren
         # we can't trust the expression range because the *target* could be a heredoc
-        # FIXME: This blows up on 2.0 with ->{}.() because it has no selector, so in this case
-        #        we would want to use the expression, but I'm ignoring that for now, because
-        #        we would have to check the target to see whether to use the selector or the expression
         elsif buffer.source[ast.location.selector.end_pos] == '('
           closing_paren_index = ast.location.selector.end_pos + 1
           closing_paren_index += 1 until buffer.source[closing_paren_index] == ')'
@@ -239,6 +244,7 @@ class SeeingIsBelieving
       puts $!
       require "pry"
       binding.pry
+      raise
     end
 
     def heredoc_hack(ast)
@@ -250,6 +256,8 @@ class SeeingIsBelieving
 
     # 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

data/spec/binary/arg_parser_spec.rb

@@ -122,25 +122,25 @@ describe SeeingIsBelieving::Binary::ArgParser do
 
   describe ':result_length' do
     it 'defaults to infinity' do
-      parse([])[:result_length].should == Float::INFINITY
+      parse([])[:max_result_length].should == Float::INFINITY
     end
 
     it 'is set with -D and --result-length' do
-      parse(['-D',              '10'])[:result_length].should == 10
-      parse(['--result-length', '10'])[:result_length].should == 10
+      parse(['-D',              '10'])[:max_result_length].should == 10
+      parse(['--result-length', '10'])[:max_result_length].should == 10
     end
 
     it_behaves_like 'it requires a positive int argument', ['-D', '--result-length']
   end
 
-  describe ':line_length' do
+  describe ':max_line_length' do
     it 'defaults to infinity' do
-      parse([])[:line_length].should == Float::INFINITY
+      parse([])[:max_line_length].should == Float::INFINITY
     end
 
     it 'is set with -d and --line-length' do
-      parse(['-d',            '10'])[:line_length].should == 10
-      parse(['--line-length', '10'])[:line_length].should == 10
+      parse(['-d',            '10'])[:max_line_length].should == 10
+      parse(['--line-length', '10'])[:max_line_length].should == 10
     end
 
     it_behaves_like 'it requires a positive int argument', ['-d', '--line-length']

data/spec/binary/clean_body_spec.rb

@@ -0,0 +1,217 @@
+require 'seeing_is_believing/binary/clean_body'
+
+describe SeeingIsBelieving::Binary::CleanBody do
+  def call(code, should_clean_values=true)
+    indentation = code[/\A */]
+    code        = code.gsub /^#{indentation}/, ''
+    described_class.call(code, should_clean_values).chomp
+  end
+
+  context 'when told to clean out value annotations' do
+    example { call("1#=>1", true).should == "1" }
+    example { call("1 #=>1", true).should == "1" }
+    example { call("1  #=>1", true).should == "1" }
+    example { call("1  #=> 1", true).should == "1" }
+    example { call("1   #=> 1", true).should == "1" }
+    example { call("1  #=>  1", true).should == "1" }
+    example { call("\n1 # => 1", true).should == "\n1" }
+  end
+
+  context 'when told not to clean out value annotations' do
+    example { call("1#=>1", false).should == "1#=>1" }
+    example { call("1 #=>1", false).should == "1 #=>1" }
+    example { call("1  #=>1", false).should == "1  #=>1" }
+    example { call("1  #=> 1", false).should == "1  #=> 1" }
+    example { call("1   #=> 1", false).should == "1   #=> 1" }
+    example { call("1  #=>  1", false).should == "1  #=>  1" }
+    example { call("\n1 # => 1", false).should == "\n1 # => 1" }
+  end
+
+  context 'cleaning inline exception annotations' do
+    example { call("1#~>1").should == "1" }
+    example { call("1 #~>1").should == "1" }
+    example { call("1  #~>1").should == "1" }
+    example { call("1  #~> 1").should == "1" }
+    example { call("1   #~> 1").should == "1" }
+    example { call("1  #~>  1").should == "1" }
+    example { call("\n1 # ~> 1").should == "\n1" }
+
+    example { call("# >> 1").should == "" }
+    example { call("# !> 1").should == "" }
+  end
+
+  context 'cleaning stdout annotations' do
+    example { call(<<-CODE).should == "1" }
+    1
+    # >> 2
+    CODE
+
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # >> 2
+    CODE
+
+    example { call(<<-CODE).should == "1\n" }
+    1
+
+
+    # >> 2
+    CODE
+
+    example { call(<<-CODE).should == "1\n" }
+    1
+
+
+      # >> 2
+    # >> 2
+     # >> 2
+    CODE
+
+
+    example { call(<<-CODE).should == "1\n" }
+    1
+
+
+    # >> 2
+    # >> 3
+    CODE
+  end
+
+  context 'cleaning stderr annotations' do
+    example { call(<<-CODE).should == "1" }
+    1
+    # !> 2
+    CODE
+
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # !> 2
+    CODE
+
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # !> 2
+    # !> 3
+    CODE
+
+    example { call(<<-CODE).should == "1\n" }
+    1
+
+
+      # !> 2
+    # !> 2
+     # !> 2
+    CODE
+  end
+
+
+  context 'cleaning end of file exception annotations' do
+    example { call(<<-CODE).should == "1" }
+    1
+    # ~>2
+    CODE
+
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # ~> 2
+    CODE
+
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # ~> 2
+    # ~> 3
+    CODE
+
+    example { call(<<-CODE).should == "1\n" }
+    1
+
+
+      # ~> 2
+    # ~> 2
+     # ~> 2
+    CODE
+
+    example { call(<<-CODE).should == "1\n" }
+    1 # ~> error
+
+
+      # ~> error again
+    CODE
+  end
+
+  context 'putting it all together' do
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # >> 1
+    # >> 2
+
+    # !> 3
+    # !> 4
+
+    # ~> 5
+    # ~> 6
+    CODE
+
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # >> 1
+
+    # >> 2
+
+    # !> 3
+
+    # !> 4
+
+    # ~> 5
+
+    # ~> 6
+    CODE
+
+    example { call(<<-CODE).should == "1" }
+    1
+
+    # >> 1
+    # >> 2
+    # !> 3
+    # !> 4
+    # ~> 5
+    # ~> 6
+    CODE
+
+    example { call(<<-CODE).should == "1\n3" }
+    1
+    # >> 1
+    # >> 2
+    3
+    # !> 4
+    # !> 5
+    CODE
+
+    example { call(<<-CODE).should == "1\n3\n6" }
+    1
+    # >> 1
+    # >> 2
+    3
+    # !> 4
+    # !> 5
+    6
+    # ~> 7
+    # ~> 8
+    CODE
+
+    example { call(<<-CODE).should == "1\n\nputs \"omg\"" }
+    1  # => 1
+
+    puts "omg"  # ~> RuntimeError: omg
+
+    # ~> RuntimeError
+    CODE
+  end
+end