seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/lib/seeing_is_believing/code.rb

@@ -0,0 +1,99 @@
+require 'parser/current'
+class SeeingIsBelieving
+  class Code
+    InlineComment = Struct.new :line_number,
+                               :whitespace_col,
+                               :whitespace,
+                               :text_col,
+                               :text,
+                               :full_range,
+                               :whitespace_range,
+                               :comment_range
+
+    # At prsent, it is expected that the syntax is validated before code arrives here
+    # or that its validity doesn't matter (e.g. extracting comments)
+    def initialize(raw_ruby_code, name="SeeingIsBelieving")
+      self.code = raw_ruby_code
+      self.name = name
+    end
+
+    def buffer()          @buffer   ||= (parse && @buffer         ) end
+    def parser()          @parser   ||= (parse && @parser         ) end
+    def rewriter()        @rewriter ||= (parse && @rewriter       ) end
+    def inline_comments() @comments ||= (parse && @inline_comments) end
+    def root()            @root     ||= (parse && @root           ) end
+
+    def range_for(start_index, end_index)
+      Parser::Source::Range.new buffer, start_index, end_index
+    end
+
+    private
+
+    attr_accessor :code, :name
+
+    def parse
+      @buffer                             = Parser::Source::Buffer.new(name)
+      @buffer.source                      = code
+      builder                             = Parser::Builders::Default.new
+      builder.emit_file_line_as_literals  = false # should be injectible?
+      @parser                             = Parser::CurrentRuby.new builder
+      @rewriter                           = Parser::Source::Rewriter.new @buffer
+
+      can_parse_invalid_code(@parser)
+
+      @root, all_comments, tokens = parser.tokenize(@buffer)
+
+      @inline_comments = all_comments.select(&:inline?).map { |c| wrap_comment c }
+    end
+
+    def can_parse_invalid_code(parser)
+      # THIS IS SO WE CAN EXTRACT COMMENTS FROM INVALID FILES.
+
+      # We do it by telling Parser's diagnostic to not blow up.
+      #   https://github.com/whitequark/parser/blob/2d69a1b5f34ef15b3a8330beb036ac4bf4775e29/lib/parser/diagnostic/engine.rb
+
+      # However, this probably implies SiB won't work on Rbx/JRuby
+      #   https://github.com/whitequark/parser/blob/2d69a1b5f34ef15b3a8330beb036ac4bf4775e29/lib/parser/base.rb#L129-134
+
+      # Ideally we could just do this
+      #   parser.diagnostics.all_errors_are_fatal = false
+      #   parser.diagnostics.ignore_warnings      = false
+
+      # But, the parser will still blow up on "fatal" errors (e.g. unterminated string) So we need to actually change it.
+      #   https://github.com/whitequark/parser/blob/2d69a1b5f34ef15b3a8330beb036ac4bf4775e29/lib/parser/diagnostic/engine.rb#L99
+
+      # We could make a NullDiagnostics like this:
+      #   class NullDiagnostics < Parser::Diagnostic::Engine
+      #     def process(*)
+      #       # no op
+      #     end
+      #   end
+
+      # But we don't control initialization of the variable, and the value gets passed around, at least into the lexer.
+      #   https://github.com/whitequark/parser/blob/2d69a1b5f34ef15b3a8330beb036ac4bf4775e29/lib/parser/base.rb#L139
+      #   and since it's all private, it could change at any time (Parser is very state based),
+      #   so I think it's just generally safer to mutate that one object, as we do now.
+      diagnostics = parser.diagnostics
+      def diagnostics.process(*)
+        self
+      end
+    end
+
+    def wrap_comment(comment)
+      last_char  = comment.location.expression.begin_pos
+      first_char = last_char
+      first_char -= 1 while first_char > 0 && code[first_char-1] =~ /[ \t]/
+      preceding_whitespace        = buffer.source[first_char...last_char]
+      preceding_whitespace_range  = range_for first_char, last_char
+
+      InlineComment.new comment.location.line,
+                        preceding_whitespace_range.column,
+                        preceding_whitespace,
+                        comment.location.column,
+                        comment.text,
+                        range_for(first_char, comment.location.expression.end_pos),
+                        preceding_whitespace_range,
+                        comment.location.expression
+    end
+  end
+end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -11,15 +11,16 @@
 # read the wrong file... of course, since we rewrite the file,
 # its body will be incorrect, anyway.
 
-require 'json'
 require 'open3'
 require 'timeout'
 require 'stringio'
-require 'fileutils'
+require 'fileutils' # DELETE?
 require 'seeing_is_believing/error'
 require 'seeing_is_believing/result'
 require 'seeing_is_believing/debugger'
 require 'seeing_is_believing/hard_core_ensure'
+require 'seeing_is_believing/event_stream/consumer'
+require 'seeing_is_believing/event_stream/update_result'
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
@@ -28,14 +29,13 @@ class SeeingIsBelieving
       new(*args).call
     end
 
-    attr_accessor :program, :filename, :input_stream, :matrix_filename, :require_flags, :load_path_flags, :encoding, :timeout, :ruby_executable, :debugger
+    attr_accessor :program, :filename, :input_stream, :require_flags, :load_path_flags, :encoding, :timeout, :ruby_executable, :debugger, :result
 
     def initialize(program, filename, options={})
       self.program         = program
       self.filename        = filename
       self.input_stream    = options.fetch :input_stream, StringIO.new('')
-      self.matrix_filename = options[:matrix_filename] || 'seeing_is_believing/the_matrix'
-      self.require_flags   = options.fetch(:require, []).map { |filename| ['-r', filename] }.flatten
+      self.require_flags   = options.fetch(:require, ['seeing_is_believing/the_matrix']).map { |filename| ['-r', filename] }.flatten
       self.load_path_flags = options.fetch(:load_path, []).map { |dir| ['-I', dir] }.flatten
       self.encoding        = options.fetch :encoding, nil
       self.timeout         = options[:timeout]
@@ -51,7 +51,8 @@ class SeeingIsBelieving
           write_program_to_file
           begin
             evaluate_file
-            deserialize_result.tap { |result| fail if result.bug_in_sib? }
+            fail if result.bug_in_sib?
+            result
           rescue Exception => error
             error = wrap_error error if error_implies_bug_in_sib? error
             raise error
@@ -102,17 +103,27 @@ class SeeingIsBelieving
 
     def evaluate_file
       Open3.popen3 ENV, *popen_args do |process_stdin, process_stdout, process_stderr, thread|
-        out_reader = Thread.new { process_stdout.read }
-        err_reader = Thread.new { process_stderr.read }
-        Thread.new do
+        # send stdin
+        Thread.new {
           input_stream.each_char { |char| process_stdin.write char }
           process_stdin.close
+        }
+
+        # consume events
+        self.result = Result.new
+        event_consumer = Thread.new do
+          EventStream::Consumer.new(process_stdout)
+                               .each { |event| EventStream::UpdateResult.call result, event }
         end
+
+        # process stderr
+        err_reader = Thread.new { process_stderr.read }
+
         begin
           Timeout::timeout timeout do
-            self.stdout     = out_reader.value
             self.stderr     = err_reader.value
             self.exitstatus = thread.value
+            event_consumer.join
           end
         rescue Timeout::Error
           Process.kill "TERM", thread.pid
@@ -126,7 +137,6 @@ class SeeingIsBelieving
          '-W0',                                     # no warnings (b/c I hijack STDOUT/STDERR)
          *(encoding ? ["-K#{encoding}"] : []),      # allow the encoding to be set
          '-I', File.expand_path('../..', __FILE__), # add lib to the load path
-         '-r', matrix_filename,                     # hijack the environment so it can be recorded
          *load_path_flags,                          # users can inject dirs to be added to the load path
          *require_flags,                            # users can inject files to be required
          filename]
@@ -136,16 +146,14 @@ class SeeingIsBelieving
       raise "Exitstatus: #{exitstatus.inspect},\nError: #{stderr.inspect}"
     end
 
-    def deserialize_result
-      Result.from_primitive JSON.load stdout
-    end
-
     def wrap_error(error)
       debugger.context "Program could not be evaluated" do
-        "Program: #{program.inspect.chomp}\n\n"\
-        "Stdout: #{stdout.inspect.chomp}\n\n"\
-        "Stderr: #{stderr.inspect.chomp}\n\n"\
-        "Status: #{exitstatus.inspect.chomp}\n"
+        "Program:      #{program.inspect.chomp}\n\n"\
+        "Stderr:       #{stderr.inspect.chomp}\n\n"\
+        "Status:       #{exitstatus.inspect.chomp}\n\n"\
+        "Result:       #{result.inspect.chomp}\n\n"\
+        "Actual Error: #{error.inspect.chomp}\n"+
+        error.backtrace.map { |sf| "              #{sf}\n" }.join("")
       end
       BugInSib.new error
     end

data/lib/seeing_is_believing/evaluate_with_eval_in.rb

@@ -0,0 +1,27 @@
+require 'eval_in'
+require 'stringio'
+
+class SeeingIsBelieving
+  class EvaluateWithEvalIn
+    def self.call(*args)
+      new(*args).call
+    end
+
+    attr_accessor :program, :filename, :input_stream, :matrix_filename, :require_flags, :load_path_flags, :encoding, :timeout, :ruby_executable, :debugger
+
+    def initialize(program, filename, options={})
+      self.program      = program
+      # self.input_stream = options.fetch :input_stream, StringIO.new('')
+      # self.timeout      = options[:timeout]
+      # self.debugger     = options.fetch :debugger, Debugger.new(stream: nil)
+    end
+
+    def call
+      eval_in_result = ::EvalIn.call(program, language: 'ruby/mri-2.1')
+      result = Result.new
+      EventStream::Consumer.new(StringIO.new eval_in_result.output)
+                           .each { |event| EventStream::UpdateResult.call result, event }
+      result
+    end
+  end
+end

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -0,0 +1,111 @@
+require 'seeing_is_believing/event_stream/events'
+require 'seeing_is_believing/error'
+class SeeingIsBelieving
+  module EventStream
+    class Consumer
+      NoMoreInput        = Class.new SeeingIsBelievingError
+      WtfWhoClosedMyShit = Class.new SeeingIsBelievingError
+
+      def initialize(readstream)
+        @readstream = readstream
+      end
+
+      def call(n=1)
+        events = n.times.map do
+          raise NoMoreInput if finished?
+          line = @readstream.gets
+          raise NoMoreInput if line.nil?
+          event = event_for line
+          @finished = true if Events::Finish === event
+          event
+        end
+        n == 1 ? events.first : events
+      rescue IOError
+        @finished = true
+        raise WtfWhoClosedMyShit, "Our end of the pipe was closed!"
+      rescue NoMoreInput
+        @finished = true
+        raise
+      end
+
+      def each
+        return to_enum :each unless block_given?
+        loop do
+          event = call
+          yield event unless Events::Finish === event
+        end
+      rescue NoMoreInput
+        return nil
+      end
+
+      def finished?
+        @finished
+      end
+
+      private
+
+      def extract_token(line)
+        event_name = line[/[^ ]+/]
+        line.sub! /^\s*[^ ]+\s*/, ''
+        event_name
+      end
+
+      # for a consideration of many different ways of doing this, see 5633064
+      def extract_string(line)
+        Marshal.load extract_token(line).unpack('m0').first
+      end
+
+      def tokenize(line)
+        line.split(' ')
+      end
+
+      def event_for(line)
+        line.chomp!
+        event_name = extract_token(line).intern
+        case event_name
+        when :result
+          line_number = extract_token(line).to_i
+          type        = extract_token(line).intern
+          inspected   = extract_string(line)
+          Events::LineResult.new(type, line_number, inspected)
+        when :maxed_result
+          line_number = extract_token(line).to_i
+          type        = extract_token(line).intern
+          Events::UnrecordedResult.new(type, line_number)
+        when :exception
+          Events::Exception.new(-1, '', '', []).tap do |exception|
+            loop do
+              line = @readstream.gets.chomp
+              case extract_token(line).intern
+              when :line_number   then exception.line_number = extract_token(line).to_i
+              when :class_name    then exception.class_name  = extract_string(line)
+              when :message       then exception.message     = extract_string(line)
+              when :backtrace     then exception.backtrace << extract_string(line)
+              when :end           then break
+              end
+            end
+          end
+        when :stdout
+          Events::Stdout.new(extract_string line)
+        when :stderr
+          Events::Stderr.new(extract_string line)
+        when :bug_in_sib
+          Events::BugInSiB.new(extract_token(line) == 'true')
+        when :max_line_captures
+          token = extract_token(line)
+          value = token =~ /infinity/i ? Float::INFINITY : token.to_i
+          Events::MaxLineCaptures.new(value)
+        when :exitstatus
+          # TODO: Will this fuck it up if you run `exit true`?
+          Events::Exitstatus.new(extract_token(line).to_i)
+        when :finish
+          Events::Finish.new
+        when :num_lines
+          Events::NumLines.new(extract_token(line).to_i)
+        else
+          raise "IDK what #{event_name.inspect} is!"
+        end
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/event_stream/events.rb

@@ -0,0 +1,16 @@
+class SeeingIsBelieving
+  module EventStream
+    module Events
+      LineResult       = Struct.new(:type, :line_number, :inspected)
+      UnrecordedResult = Struct.new(:type, :line_number)
+      Stdout           = Struct.new(:value)
+      Stderr           = Struct.new(:value)
+      BugInSiB         = Struct.new(:value)
+      MaxLineCaptures  = Struct.new(:value)
+      NumLines         = Struct.new(:value)
+      Exitstatus       = Struct.new(:value)
+      Exception        = Struct.new(:line_number, :class_name, :message, :backtrace)
+      Finish           = Class.new
+    end
+  end
+end

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -0,0 +1,106 @@
+require 'seeing_is_believing/event_stream/events'
+class SeeingIsBelieving
+  module EventStream
+    require 'thread'
+    class Producer
+      attr_accessor :exitstatus, :bug_in_sib, :max_line_captures, :num_lines
+
+      def initialize(resultstream)
+        self.exitstatus        = 0
+        self.bug_in_sib        = false
+        self.max_line_captures = Float::INFINITY
+        self.num_lines         = 0
+        self.recorded_results  = []
+        self.queue             = Thread::Queue.new
+        self.producer_thread   = Thread.new do
+          finish = "finish"
+          begin
+            loop do
+              to_publish = queue.shift
+              if to_publish == finish
+                resultstream << "finish\n"
+                break
+              else
+                resultstream << (to_publish << "\n")
+              end
+            end
+          rescue IOError, Errno::EPIPE
+            loop { break if queue.shift == finish }
+          end
+        end
+      end
+
+      def bug_in_sib=(bool)
+        @bug_in_sib = (bool ? true : false)
+      end
+
+      # for a consideration of many different ways of doing this, see 5633064
+      def to_string_token(string)
+        [Marshal.dump(string.to_s)].pack('m0')
+      end
+
+      StackErrors = [SystemStackError]
+      StackErrors << Java::JavaLang::StackOverflowError if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java'
+      def record_result(type, line_number, value)
+        self.num_lines = line_number if num_lines < line_number
+        counts = recorded_results[line_number] ||= Hash.new(0)
+        count  = counts[type]
+        recorded_results[line_number][type] = count.next
+        if count < max_line_captures
+          begin
+            if block_given?
+              inspected = yield(value).to_str
+            else
+              inspected = value.inspect.to_str
+            end
+          rescue *StackErrors
+            # this is necessary because SystemStackError won't show the backtrace of the method we tried to call
+            # which means there won't be anything showing the user where this came from
+            # so we need to re-raise the error to get a backtrace that shows where we came from
+            # otherwise it looks like the bug is in SiB and not the user's program, see https://github.com/JoshCheek/seeing_is_believing/issues/37
+            raise SystemStackError, "Calling inspect blew the stack (is it recursive w/o a base case?)"
+          rescue Exception
+            inspected = "#<no inspect available>"
+          end
+          queue << "result #{line_number} #{type} #{to_string_token inspected}"
+        elsif count == max_line_captures
+          queue << "maxed_result #{line_number} #{type}"
+        end
+        value
+      end
+
+      def record_exception(line_number, exception)
+        self.num_lines = line_number if num_lines < line_number
+        queue << "exception"
+        queue << "  line_number #{line_number}"
+        queue << "  class_name  #{to_string_token exception.class.name}"
+        queue << "  message     #{to_string_token exception.message}"
+        exception.backtrace.each { |line|
+          queue << "  backtrace   #{to_string_token line}"
+        }
+        queue << "end"
+      end
+
+      def record_stdout(stdout)
+        queue << "stdout #{to_string_token stdout}"
+      end
+
+      def record_stderr(stderr)
+        queue << "stderr #{to_string_token stderr}"
+      end
+
+      def finish!
+        queue << "bug_in_sib #{bug_in_sib}"
+        queue << "max_line_captures #{max_line_captures}"
+        queue << "num_lines #{num_lines}"
+        queue << "exitstatus #{exitstatus}"
+        queue << "finish".freeze
+        producer_thread.join
+      end
+
+      private
+
+      attr_accessor :resultstream, :queue, :producer_thread, :recorded_results
+    end
+  end
+end