seeing_is_believing 0.0.9 → 0.0.10

data/lib/seeing_is_believing/binary.rb

@@ -1,5 +1,7 @@
-require 'seeing_is_believing/arg_parser'
-require 'seeing_is_believing/print_results_next_to_lines'
+require 'seeing_is_believing'
+require 'seeing_is_believing/binary/arg_parser'
+require 'seeing_is_believing/binary/print_results_next_to_lines'
+
 
 class SeeingIsBelieving
   class Binary
@@ -17,7 +19,7 @@ class SeeingIsBelieving
                       elsif should_print_help?          then print_help         ; 0
                       elsif has_filename? && file_dne?  then print_file_dne     ; 1
                       elsif invalid_syntax?             then print_syntax_error ; 1
-                      else                                   print_program      ; (printer.has_exception? ? 1 : 0)
+                      else                                   print_program      ; (results.has_exception? ? 1 : 0)
                       end
     end
 
@@ -25,27 +27,23 @@ class SeeingIsBelieving
 
     private
 
-    def filename
+    def has_filename?
       flags[:filename]
     end
-    alias has_filename? filename
 
-    # le sigh
+    def body
+      @body ||= PrintResultsNextToLines.remove_previous_output_from \
+                  (file_is_on_stdin? ? stdin.read : File.read(flags[:filename]))
+    end
+
+    def results
+      @results ||= SeeingIsBelieving.call body,
+                                          filename: flags[:filename],
+                                          stdin: (file_is_on_stdin? ? '' : stdin)
+    end
+
     def printer
-      @printer ||= begin
-        if file_is_on_stdin?
-          body  = stdin.read
-          stdin = ''
-        else
-          body  = File.read(filename)
-          stdin = self.stdin
-        end
-        PrintResultsNextToLines.new body,
-                                    stdin,
-                                    filename:   filename,
-                                    start_line: flags[:start_line],
-                                    end_line:   flags[:end_line]
-      end
+      @printer ||= PrintResultsNextToLines.new body, results, flags
     end
 
     def flags
@@ -69,15 +67,15 @@ class SeeingIsBelieving
     end
 
     def file_is_on_stdin?
-      filename.nil?
+      flags[:filename].nil?
     end
 
     def file_dne?
-      !File.exist?(filename)
+      !File.exist?(flags[:filename])
     end
 
     def print_file_dne
-      stderr.puts "#{filename} does not exist!"
+      stderr.puts "#{flags[:filename]} does not exist!"
     end
 
     def print_program
@@ -85,8 +83,8 @@ class SeeingIsBelieving
     end
 
     def syntax_error_notice
-      return if file_is_on_stdin? # <-- should probably check stdin too
-      out, err, syntax_status = Open3.capture3('ruby', '-c', filename)
+      return if file_is_on_stdin? # <-- BUG: should check stdin too
+      out, err, syntax_status = Open3.capture3 'ruby', '-c', flags[:filename]
       return err unless syntax_status.success?
     end
 
@@ -97,5 +95,6 @@ class SeeingIsBelieving
     def print_syntax_error
       stderr.puts syntax_error_notice
     end
+
   end
 end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -20,17 +20,18 @@ require 'seeing_is_believing/hard_core_ensure'
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
-    attr_accessor :program, :filename, :error_stream, :input_stream
+    attr_accessor :program, :filename, :error_stream, :input_stream, :matrix_filename
 
     def initialize(program, filename, options={})
-      self.program      = program
-      self.filename     = File.expand_path(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.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'
     end
 
     def call
-      @result ||= HardCoreEnsure.call(
+      @result ||= HardCoreEnsure.call \
         code: -> {
           dont_overwrite_existing_tempfile!
           move_file_to_tempfile
@@ -47,7 +48,6 @@ class SeeingIsBelieving
         ensure: -> {
           restore_backup
         }
-      )
     end
 
     def file_directory
@@ -83,9 +83,8 @@ class SeeingIsBelieving
 
     def evaluate_file
       Open3.popen3 'ruby', '-W0',                                     # no warnings (b/c I hijack STDOUT/STDERR)
-                           '-I', File.expand_path('../..', __FILE__), # fix load path
-                           '-r', 'seeing_is_believing/the_matrix',    # hijack the environment so it can be recorded
-                           '-C', file_directory,                      # run in the file's directory
+                           '-I', File.expand_path('../..', __FILE__), # add lib to the load path
+                           '-r', matrix_filename,                     # hijack the environment so it can be recorded
                            filename do |i, o, e, t|
         out_reader = Thread.new { o.read }
         err_reader = Thread.new { e.read }

data/lib/seeing_is_believing/expression_list.rb

@@ -21,19 +21,18 @@ class SeeingIsBelieving
       self.get_next_line  = options.fetch :get_next_line
       self.peek_next_line = options.fetch :peek_next_line
       self.on_complete    = options.fetch :on_complete
-      @line_number        = 0
     end
 
     def call
-      expressions = []
-      expression = nil
+      offset, expressions, expression = 0, [], nil
       begin
         pending_expression = generate
         debug { "GENERATED: #{pending_expression.expression.inspect}, ADDING IT TO #{inspected_expressions expressions}" }
         expressions << pending_expression
-        expression = reduce expressions unless next_line_modifies_current?
+        expression = reduce expressions, offset unless next_line_modifies_current?
+        offset += 1
       end until expressions.empty?
-      expression
+      return expression, offset
     end
 
     private
@@ -41,7 +40,6 @@ class SeeingIsBelieving
     attr_accessor :debug_stream, :should_debug, :get_next_line, :peek_next_line, :on_complete, :expressions
 
     def generate
-      @line_number += 1
       expression = get_next_line.call
       raise SyntaxError unless expression
       PendingExpression.new(expression, [])
@@ -49,9 +47,8 @@ class SeeingIsBelieving
 
     def next_line_modifies_current?
       # method invocations can be put on the next line, and begin with a dot.
-      # I think that's the only case we need to worry about. e.g:
-      # 3
-      #  .times { |i| p i }
+      # I think that's the only case we need to worry about.
+      # e.g: `3\n.times { |i| p i }`
       peek_next_line.call && peek_next_line.call =~ /^\s*\./
     end
 
@@ -67,7 +64,7 @@ class SeeingIsBelieving
       @debug_stream.puts yield if debug?
     end
 
-    def reduce(expressions)
+    def reduce(expressions, offset)
       expressions.size.times do |i|
         expression = expressions[i..-1].map(&:expression) # uhm, should this expression we are checking for validity consider the children?
                                        .join("\n")        # must use newline otherwise can get expressions like `a\\+b` that should be `a\\\n+b`, former is invalid
@@ -76,7 +73,7 @@ class SeeingIsBelieving
         result = on_complete.call(expressions[i].expression,
                                   expressions[i].children,
                                   expressions[i+1..-1].map { |pe| [pe.expression, pe.children] }.flatten, # hmmm, not sure this is really correct, but it allows it to work for my use cases
-                                  @line_number)
+                                  offset)
         expressions.replace expressions[0, i]
         expressions[i-1].children << result unless expressions.empty?
         debug { "REDUCED: #{result.inspect}, LIST: #{inspected_expressions expressions}" }

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

data/lib/seeing_is_believing.rb

@@ -11,18 +11,49 @@ class SeeingIsBelieving
   include TracksLineNumbersSeen
   BLANK_REGEX = /\A\s*\Z/
 
+  def self.call(*args)
+    new(*args).call
+  end
+
   def initialize(string_or_stream, options={})
-    @string   = string_or_stream
-    @stream   = to_stream string_or_stream
-    @filename = options[:filename]
-    @stdin    = to_stream options.fetch(:stdin, '')
+    @string          = string_or_stream
+    @stream          = to_stream string_or_stream
+    @matrix_filename = options[:matrix_filename]
+    @filename        = options[:filename]
+    @stdin           = to_stream options.fetch(:stdin, '')
+    @line_number     = 1
   end
 
+  # :( refactor me
   def call
     @memoized_result ||= begin
+      # extract leading comments, leading =begin and magic comments can't be wrapped for exceptions without breaking
+      leading_comments = ''
+      while next_line_queue.peek =~ /^\s*#/
+        leading_comments << next_line_queue.dequeue << "\n"
+        @line_number += 1
+      end
+      while next_line_queue.peek == '=begin'
+        lines = next_line_queue.dequeue << "\n"
+        @line_number += 1
+        until SyntaxAnalyzer.begin_and_end_comments_are_complete? lines
+          lines << next_line_queue.dequeue << "\n"
+          @line_number += 1
+        end
+        leading_comments << lines
+      end
+
+      # extract program
       program = ''
-      program << expression_list.call until next_line_queue.peek.nil? || data_segment?
-      program = record_exceptions_in program
+      until next_line_queue.peek.nil? || data_segment?
+        expression, expression_size = expression_list.call
+        program << expression
+        track_line_number @line_number
+        @line_number += expression_size
+      end
+      program = leading_comments + record_exceptions_in(program)
+
+      # extract data segment
       program << "\n" << the_rest_of_the_stream if data_segment?
       result_for program, min_line_number, max_line_number
     end
@@ -30,18 +61,17 @@ class SeeingIsBelieving
 
   private
 
-  attr_reader :stream
+  attr_reader :stream, :matrix_filename
 
   def expression_list
     @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, line_number|
-                                              track_line_number line_number
+                                            on_complete:    lambda { |line, children, completions, offset|
                                               expression = [line, *children, *completions].map(&:chomp).join("\n")
                                               if do_not_record? expression
                                                 expression + "\n"
                                               else
-                                                record_yahself(expression, line_number) + "\n"
+                                                record_yahself(expression, @line_number+offset) + "\n"
                                               end
                                             }
   end
@@ -68,7 +98,7 @@ class SeeingIsBelieving
   def result_for(program, min_line_number, max_line_number)
     Dir.mktmpdir "seeing_is_believing_temp_dir" do |dir|
       filename = @filename || File.join(dir, 'program.rb')
-      EvaluateByMovingFiles.new(program, filename, input_stream: @stdin).call.tap do |result|
+      EvaluateByMovingFiles.new(program, filename, input_stream: @stdin, matrix_filename: matrix_filename).call.tap do |result|
         result.track_line_number min_line_number
         result.track_line_number max_line_number
       end
@@ -84,10 +114,7 @@ class SeeingIsBelieving
   end
 
   def next_line_queue
-    @next_line_queue ||= Queue.new do
-      line = stream.gets
-      line && line.chomp
-    end
+    @next_line_queue ||= Queue.new { (line = stream.gets) && line.chomp }
   end
 
   def the_rest_of_the_stream

data/spec/arg_parser_spec.rb

@@ -1,6 +1,6 @@
-require 'seeing_is_believing/arg_parser'
+require 'seeing_is_believing/binary/arg_parser'
 
-describe SeeingIsBelieving::ArgParser do
+describe SeeingIsBelieving::Binary::ArgParser do
   RSpec::Matchers.define :have_error do |error_assertion|
     match do |options|
       options[:errors].find do |error|
@@ -26,6 +26,20 @@ describe SeeingIsBelieving::ArgParser do
     described_class.parse args
   end
 
+  shared_examples 'it requires a positive int argument' do |flags|
+    it 'expects an integer argument' do
+      flags.each do |flag|
+        parse([flag,   '1']).should_not have_error /#{flag}/
+        parse([flag,   '0']).should     have_error /#{flag}/
+        parse([flag,  '-1']).should     have_error /#{flag}/
+        parse([flag, '1.0']).should     have_error /#{flag}/
+        parse([flag,   'a']).should     have_error /#{flag}/
+        parse([flag,   '' ]).should     have_error /#{flag}/
+        parse([flag       ]).should     have_error /#{flag}/
+      end
+    end
+  end
+
   specify 'unknown options set an error' do
     parse(['--abc']).should have_error 'Unknown option: "--abc"'
     parse(['-a']).should have_error 'Unknown option: "-a"'
@@ -68,18 +82,7 @@ describe SeeingIsBelieving::ArgParser do
       parse(['--start-line', '12'])[:start_line].should == 12
     end
 
-    it 'sets an error if it cannot be turned into a positive integer' do
-      line_error_assertions = lambda do |flag|
-        parse([flag, '1']).should_not have_error /#{flag}/
-        parse([flag, '0']).should have_error /#{flag}/
-        parse([flag, 'a']).should have_error /#{flag}/
-        parse([flag, '']).should have_error /#{flag}/
-        parse([flag, '1.0']).should have_error /#{flag}/
-        parse([flag]).should have_error /#{flag}/
-      end
-      line_error_assertions['-l']
-      line_error_assertions['--start-line']
-    end
+    it_behaves_like 'it requires a positive int argument', ['-l', '--start-line']
   end
 
   describe ':end_line' do
@@ -92,16 +95,7 @@ describe SeeingIsBelieving::ArgParser do
       parse(['--end-line', '12'])[:end_line].should == 12
     end
 
-    it 'sets an error if it cannot be turned into an integer' do
-      line_error_assertions = lambda do |flag|
-        parse([flag, '1']).should_not have_error /#{flag}/
-        parse([flag, 'a']).should have_error /#{flag}/
-        parse([flag, '']).should have_error /#{flag}/
-        parse([flag]).should have_error /#{flag}/
-      end
-      line_error_assertions['-L']
-      line_error_assertions['--end-line']
-    end
+    it_behaves_like 'it requires a positive int argument', ['-L', '--end-line']
   end
 
   it 'swaps start and end line around if they are out of order' do
@@ -109,6 +103,32 @@ describe SeeingIsBelieving::ArgParser do
     parse(%w[-l 2 -L 1])[:end_line].should == 2
   end
 
+  describe ':result_length' do
+    it 'defaults to infinity' do
+      parse([])[: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
+    end
+
+    it_behaves_like 'it requires a positive int argument', ['-D', '--result-length']
+  end
+
+  describe ':line_length' do
+    it 'defaults to infinity' do
+      parse([])[: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
+    end
+
+    it_behaves_like 'it requires a positive int argument', ['-d', '--line-length']
+  end
+
   describe ':help' do
     it 'defaults to nil' do
       parse([])[:help].should be_nil

data/spec/evaluate_by_moving_files_spec.rb

@@ -68,11 +68,4 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
     expect { evaluator.call }.to raise_error
     stderr.string.should include "It blew up"
   end
-
-  it "doesn't block waiting for io on stdin" do
-    reader, writer = IO.pipe
-    thread = Thread.new { invoke '1', input_stream: reader }
-    sleep 0.05
-    thread.should_not be_alive
-  end
 end

data/spec/expression_list_spec.rb

@@ -16,31 +16,32 @@ describe SeeingIsBelieving::ExpressionList do
 
   example 'example: multiple children' do
     block_invocations = 0
-    result = call %w[a( b+ c x\\ + y )] do |line, children, completions, line_number|
-      case line_number
-      when 3
+    result, size = call %w[a( b+ c x\\ + y )] do |line, children, completions, offset|
+      case offset
+      when 2
         line.should == 'b+'
         children.should == []
         completions.should == ['c']
         block_invocations += 1
         'b+c'
-      when 6
+      when 5
         line.should == 'x\\'
         children.should == []
         completions.should == ['+', 'y']
         block_invocations += 10
         'x\\+y'
-      when 7
+      when 6
         line.should == 'a('
         children.should == ['b+c', 'x\\+y']
         completions.should == [')']
         block_invocations += 100
         'ALL DONE!'
       else
-        raise "line_number: #{line_number.inspect}"
+        raise "offset: #{offset.inspect}"
       end
     end
     result.should == 'ALL DONE!'
+    size.should == 7
     block_invocations.should == 111
   end
 
@@ -53,15 +54,15 @@ describe SeeingIsBelieving::ExpressionList do
                     '  end',
                     'end',
                   ]
-    result = call expressions do |line, children, completions, line_number|
-      case line_number
-      when 3
+    result, size = call expressions do |line, children, completions, offset|
+      case offset
+      when 2
         [line, children, completions].should == ['    n1 + n2', [], []]
         block_invocations += 1
-      when 4
+      when 3
         [line, children, completions].should == ['  [2].map do |n2|', ['    n1 + n2'], ['  end']]
         block_invocations += 10
-      when 5
+      when 4
         [line, children, completions].should == ['[1].map do |n1|',
                                                  ["  [2].map do |n2|\n    n1 + n2\n  end"],
                                                  ['end']]
@@ -77,6 +78,7 @@ describe SeeingIsBelieving::ExpressionList do
                       "    n1 + n2\n"\
                       "  end\n"\
                       "end"
+    size.should == 5
   end
 
 
@@ -87,12 +89,12 @@ describe SeeingIsBelieving::ExpressionList do
                         "n1 + n2",
                      "end end",
                   ]
-    result = call expressions do |line, children, completions, line_number|
-      case line_number
-      when 3
+    result, size = call expressions do |line, children, completions, offset|
+      case offset
+      when 2
         [line, children, completions].should == ["n1 + n2", [], []]
         block_invocations += 1
-      when 4
+      when 3
         # not really sure what this *should* be like, but if this is the result,
         # then it will work for the use cases I need it for
         [line, *children, *completions].should == ["[1].map do |n1|",
@@ -101,7 +103,7 @@ describe SeeingIsBelieving::ExpressionList do
                                                    'end end']
         block_invocations += 10
       else
-        raise "line_number: #{line_number.inspect}"
+        raise "offset: #{offset.inspect}"
       end
       [line, *children, *completions].join("\n")
     end
@@ -109,14 +111,15 @@ describe SeeingIsBelieving::ExpressionList do
     result.should == "[1].map do |n1|\n"\
                       "[2].map do |n2|\n"\
                         "n1 + n2\n"\
-                     "end end"\
+                     "end end"
+    size.should == 4
   end
 
   example 'example: multiline strings with valid code in them' do
     block_invocations = 0
-    call ["'", "1", "'"] do |*expressions, line_number|
+    call ["'", "1", "'"] do |*expressions, offset|
       expressions.join('').should == "'1'"
-      line_number.should == 3
+      offset.should == 2
       block_invocations += 1
     end
     block_invocations.should == 1
@@ -124,9 +127,9 @@ describe SeeingIsBelieving::ExpressionList do
 
   example 'example: multiline regexps with valid code in them' do
     block_invocations = 0
-    call ['/', '1', '/'] do |*expressions, line_number|
+    call ['/', '1', '/'] do |*expressions, offset|
       expressions.join('').should == "/1/"
-      line_number.should == 3
+      offset.should == 2
       block_invocations += 1
     end
     block_invocations.should == 1
@@ -134,9 +137,9 @@ describe SeeingIsBelieving::ExpressionList do
 
   example "example: =begin/=end comments" do
     block_invocations = 0
-    call ['=begin', '1', '=end'] do |*expressions, line_number|
+    call ['=begin', '1', '=end'] do |*expressions, offset|
       expressions.join('').should == "=begin1=end"
-      line_number.should == 3
+      offset.should == 2
       block_invocations += 1
     end
     block_invocations.should == 1
@@ -144,31 +147,32 @@ describe SeeingIsBelieving::ExpressionList do
 
   example "example: heredoc" do
     pending 'Not sure how to do this, for now just catch it at a higher level' do
-      result = call ['strings = [<<A, <<-B]', '1', 'A', '2', ' B'] do |*expressions, line_number|
-        line_number.should == 1
+      result, size = call ['strings = [<<A, <<-B]', '1', 'A', '2', ' B'] do |*expressions, offset|
+        offset.should == 1
         expressions.should == ['strings = [<<A, <<B]']
         'zomg!'
       end
       result.should == "zomg!\n1\nA\n2\n B"
+      size.should == 5
     end
   end
 
   example "example: method invocations on next line" do
     # example 1: consume the expression with lines after
-    list = list_for ['a', '.b', ' .c', 'irrelevant'] do |*expressions, line_number|
-      line_number.should == 3
+    list = list_for ['a', '.b', ' .c', 'irrelevant'] do |*expressions, offset|
+      offset.should == 2
       expressions.flatten.join('').should == 'a.b .c'
       'a.b.c'
     end
-    list.call.should == 'a.b.c'
+    list.call.should == ['a.b.c', 3]
 
     # example 2: consume the expression with no lines after
-    list = list_for ['a', '.b'] do |*expressions, line_number|
-      line_number.should == 2
+    list = list_for ['a', '.b'] do |*expressions, offset|
+      offset.should == 1
       expressions.flatten.join('').should == 'a.b'
       'result'
     end
-    list.call.should == 'result'
+    list.call.should == ['result', 2]
   end
 
   example "example: smoke test debug option" do