seeing_is_believing 3.0.0.beta.4 → 3.0.0.beta.5

data/lib/seeing_is_believing/debugger.rb

@@ -1,7 +1,6 @@
 class SeeingIsBelieving
   class Debugger
-
-    CONTEXT_COLOUR = "\e[37;44m"
+    CONTEXT_COLOUR = "\e[37;44m" # background blue
     RESET_COLOUR   = "\e[0m"
 
     def initialize(options={})
@@ -9,6 +8,8 @@ class SeeingIsBelieving
       @stream   = options[:stream]
     end
 
+    Null = new stream: nil
+
     def coloured?
       @coloured
     end
@@ -18,14 +19,14 @@ class SeeingIsBelieving
 
     def context(name, &block)
       if enabled?
-        stream << CONTEXT_COLOUR          if coloured?
+        stream << CONTEXT_COLOUR if coloured?
         stream << "#{name}:"
-        stream << RESET_COLOUR            if coloured?
+        stream << RESET_COLOUR   if coloured?
         stream << "\n"
         stream << block.call.to_s << "\n" if block
       end
       self
     end
-
   end
+
 end

data/lib/seeing_is_believing/error.rb

@@ -1,28 +1,17 @@
 class SeeingIsBelieving
-  # all our errors will inherit from this so that a user
-  # can catch any error generated by this lib
+  # All our errors will inherit from this so that a user can catch any error generated by this lib
   SeeingIsBelievingError = Class.new StandardError
 
   class TempFileAlreadyExists < SeeingIsBelievingError
-    def initialize(from_filename, temp_filename)
+    def initialize(from_filename, backup_filename)
       super "Trying to back up #{from_filename.inspect} (FILE) to"\
-            " #{temp_filename.inspect} (TEMPFILE) but TEMPFILE already exists."\
+            " #{backup_filename.inspect} (TEMPFILE) but TEMPFILE already exists."\
             " You should check the contents of these files. If FILE is correct,"\
             " then delete TEMPFILE. Otherwise rename TEMPFILE to FILE."
     end
   end
 
-  class BugInSib < SeeingIsBelievingError
-    def initialize(error)
-      require 'parser/version'
-      require 'seeing_is_believing/version'
-
-      super "It blew up >.< Please log an issue at: https://github.com/JoshCheek/seeing_is_believing/issues\n"\
-            "SeeingIsBelieving::VERSION  #{SeeingIsBelieving::VERSION.inspect}\n"\
-            "Parser::VERSION             #{Parser::VERSION.inspect}\n"\
-            "RUBY_VERSION                #{RUBY_VERSION.inspect}\n"\
-            "ENV['RUBY_VERSION']         #{ENV['RUBY_VERSION'].inspect}\n"\
-            "Also include the source code of program that caused this behaviour."
-    end
-  end
+  # EventStream
+  NoMoreEvents = Class.new SeeingIsBelievingError
+  UnknownEvent = Class.new SeeingIsBelievingError
 end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -11,89 +11,42 @@
 # read the wrong file... of course, since we rewrite the file,
 # its body will be incorrect, anyway.
 
-require 'open3'
 require 'timeout'
-require 'stringio'
-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
-
-    # *sigh* have to do this b/c can't use Open3, b/c keywords don't work right when the keys are not symbols, and I'm passing a file descriptor
-    # https://github.com/ruby/ruby/pull/808    my pr
-    # https://bugs.ruby-lang.org/issues/10699  they opened an issue
-    # https://bugs.ruby-lang.org/issues/10118  weird feature vs bug conversation
-    module Spawn
-      extend self
-      def popen(*cmd)
-        opts = {}
-        opts = cmd.pop if cmd.last.kind_of? Hash
-
-        in_r, in_w = IO.pipe
-        opts[:in] = in_r
-        in_w.sync = true
-
-        out_r, out_w = IO.pipe
-        opts[:out] = out_w
-
-        err_r, err_w = IO.pipe
-        opts[:err] = err_w
-
-        pid       = spawn(*cmd, opts)
-        wait_thr  = Process.detach(pid)
-
-        in_r.close
-        out_w.close
-        err_w.close
-
-        begin
-          yield in_w, out_r, err_r, wait_thr
-          in_w.close unless in_w.closed?
-          wait_thr.value
-        ensure
-          [in_w, out_r, err_r].each { |io| io.close unless io.closed? }
-          wait_thr.join
-        end
-      end
-    end
-
-
     def self.call(*args)
       new(*args).call
     end
 
-    attr_accessor :program, :filename, :input_stream, :require_flags, :load_path_flags, :encoding, :timeout, :debugger, :result
-
-    def initialize(program, filename, options={})
-      self.program         = program
-      self.filename        = filename
-      self.input_stream    = options.fetch :input_stream, StringIO.new('')
-      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]
-      self.debugger        = options.fetch :debugger, Debugger.new(stream: nil)
+    attr_accessor :program, :filename, :provided_input, :require_flags, :load_path_flags, :encoding, :timeout_seconds, :debugger, :event_handler, :max_line_captures
+
+    def initialize(program, filename,  options={})
+      options = options.dup
+      self.program           = program
+      self.filename          = filename
+      self.encoding          = options.delete(:encoding)
+      self.timeout_seconds   = options.delete(:timeout_seconds)    || 0 # 0 is the new infinity
+      self.provided_input    = options.delete(:provided_input)     || String.new
+      self.event_handler     = options.delete(:event_handler)      || raise("must provide an event handler")
+      self.load_path_flags   = (options.delete(:load_path_dirs)    || []).map { |dir| ['-I', dir] }.flatten
+      self.require_flags     = (options.delete(:require_files)     || ['seeing_is_believing/the_matrix']).map { |filename| ['-r', filename] }.flatten
+      self.max_line_captures = (options.delete(:max_line_captures) || Float::INFINITY) # (optimization: child stops producing results at this number, even though it might make more sense for the consumer to stop emitting them)
+      options.any? && raise(ArgumentError, "Unknown options: #{options.inspect}")
     end
 
     def call
-      @result ||= HardCoreEnsure.call \
+      HardCoreEnsure.call \
         code: -> {
-          we_will_not_overwrite_existing_tempfile!
-          move_file_to_tempfile
+          we_will_not_overwrite_existing_backup_file!
+          backup_existing_file
           write_program_to_file
-          begin
-            evaluate_file
-            result
-          rescue Exception => error
-            error = wrap_error error unless error.kind_of? Timeout::Error
-            raise error
-          end
+          evaluate_file
         },
         ensure: -> {
           set_back_to_initial_conditions
@@ -104,75 +57,87 @@ class SeeingIsBelieving
       File.dirname filename
     end
 
-    def temp_filename
+    def backup_filename
       File.join file_directory, "seeing_is_believing_backup.#{File.basename filename}"
     end
 
     private
 
-    attr_accessor :stdout, :stderr, :exitstatus
-
-    def we_will_not_overwrite_existing_tempfile!
-      raise TempFileAlreadyExists.new(filename, temp_filename) if File.exist? temp_filename
+    def we_will_not_overwrite_existing_backup_file!
+      raise TempFileAlreadyExists.new(filename, backup_filename) if File.exist? backup_filename
     end
 
-    def move_file_to_tempfile
+    def backup_existing_file
       return unless File.exist? filename
-      FileUtils.mv filename, temp_filename
+      File.rename filename, backup_filename
       @was_backed_up = true
     end
 
     def set_back_to_initial_conditions
-      if @was_backed_up
-        FileUtils.mv temp_filename, filename
-      else
-        FileUtils.rm filename
-      end
+      @was_backed_up ?
+        File.rename(backup_filename, filename) :
+        File.delete(filename)
     end
 
     def write_program_to_file
       File.open(filename, 'w') { |f| f.write program.to_s }
     end
 
+    # have to basically copy a bunch of Open3 code into here b/c keywords don't work right when the keys are not symbols
+    # https://github.com/ruby/ruby/pull/808    my PR
+    # https://bugs.ruby-lang.org/issues/10699  they opened an issue
+    # https://bugs.ruby-lang.org/issues/10118  weird feature vs bug conversation
     def evaluate_file
-      # the event stream
-      es_read, es_write = IO.pipe
-      es_fd = es_write.to_i.to_s
-
-      # invoke the process
-      Spawn.popen ENV, *popen_args, es_fd, es_write => es_write do |process_stdin, process_stdout, process_stderr, thread|
-        # child writes here, we close b/c won't get EOF until all fds are closed
-        es_write.close
-
-        # send stdin
-        Thread.new {
-          input_stream.each_char { |char| process_stdin.write char }
-          process_stdin.close
-        }
-
-        # consume events
-        self.result = Result.new # set on self b/c if an error is raised, we still want to keep what we recorded
-        event_consumer = Thread.new do
-          EventStream::Consumer
-            .new(events: es_read, stdout: process_stdout, stderr: process_stderr)
-            .each { |event| EventStream::UpdateResult.call result, event }
-        end
-
-        begin
-          Timeout::timeout timeout do
-            event_consumer.join
-            # TODO: seems like these belong entirely on result, not as ivars of this class
-            self.exitstatus = thread.value
-            self.stderr     = result.stderr
-          end
-        rescue Timeout::Error
-          Process.kill "TERM", thread.pid
-          raise $!
-        end
+      # setup streams
+      eventstream, child_eventstream = IO.pipe
+      stdout,      child_stdout      = IO.pipe
+      stderr,      child_stderr      = IO.pipe
+      child_stdin, stdin             = IO.pipe
+
+      # setup environment variables
+      env = ENV.to_hash.merge 'SIB_VARIABLES.MARSHAL.B64' =>
+                                [Marshal.dump(
+                                  event_stream_fd:   child_eventstream.to_i,
+                                  max_line_captures: max_line_captures,
+                                  num_lines:         program.lines.count,
+                                  filename:          filename
+                                )].pack('m0')
+
+      # evaluate the code in a child process
+      opts = { in:                  child_stdin,
+               out:                 child_stdout,
+               err:                 child_stderr,
+               child_eventstream => child_eventstream }
+      child = Process.detach Kernel.spawn(env, *popen_args, opts)
+
+      # close b/c we won't get EOF until all fds are closed
+      child_eventstream.close
+      child_stdout.close
+      child_stderr.close
+      child_stdin.close
+      stdin.sync = true
+
+      # send stdin
+      Thread.new {
+        provided_input.each_char { |char| stdin.write char }
+        stdin.close
+      }
+
+      # consume events
+      consumer        = EventStream::Consumer.new(events: eventstream, stdout: stdout, stderr: stderr)
+      consumer_thread = Thread.new { consumer.each { |e| event_handler.call e } }
+
+      # wait for completion
+      Timeout.timeout timeout_seconds do
+        exitstatus = child.value.exitstatus
+        consumer.process_exitstatus exitstatus
+        consumer_thread.join
       end
+    rescue Timeout::Error
+      Process.kill "TERM", child.pid
+      raise
     ensure
-      es_read.close  unless es_read.closed?
-      es_write.close unless es_write.closed?
+      [stdin, stdout, stderr, eventstream].each { |io| io.close unless io.closed? }
     end
 
     def popen_args
@@ -184,21 +149,5 @@ class SeeingIsBelieving
          *require_flags,                            # users can inject files to be required
          filename]
     end
-
-    def fail
-      raise "Exitstatus: #{exitstatus.inspect},\nError: #{stderr.inspect}"
-    end
-
-    def wrap_error(error)
-      debugger.context "Program could not be evaluated" do
-        "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
   end
 end

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'seeing_is_believing/event_stream/events'
 require 'seeing_is_believing/error'
 require 'thread'
@@ -5,36 +7,79 @@ require 'thread'
 class SeeingIsBelieving
   module EventStream
     class Consumer
-      NoMoreInput        = Class.new SeeingIsBelievingError
-      WtfWhoClosedMyShit = Class.new SeeingIsBelievingError
-      UnknownEvent       = Class.new SeeingIsBelievingError
+      class FinishCriteria
+        CRITERIA = [
+          :event_thread_finished!,
+          :stdout_thread_finished!,
+          :stderr_thread_finished!,
+          :process_exited!,
+        ].freeze.each do |name|
+          define_method name do
+            @unmet_criteria.delete name
+            @satisfied = @unmet_criteria.empty?
+          end
+        end
+        def initialize
+          @satisfied      = false
+          @unmet_criteria = CRITERIA.dup
+        end
+        def satisfied?
+          @satisfied
+        end
+      end
+
+      # https://github.com/JoshCheek/seeing_is_believing/issues/46
+      def self.fix_encoding(str)
+        str.encode! Encoding::UTF_8
+      rescue EncodingError
+        str = str.force_encoding(Encoding::UTF_8)
+        return str.scrub('�') if str.respond_to? :scrub # b/c it's not implemented on 1.9.3
+        str.each_char.inject("") do |new_str, char|
+          if char.valid_encoding?
+            new_str << char
+          else
+            new_str << '�'
+          end
+        end
+      end
 
       def initialize(streams)
-        self.finished_threads = []
-        self.queue            = Queue.new
-        self.event_stream     = streams.fetch :events
-        stdout_stream         = streams.fetch :stdout
-        stderr_stream         = streams.fetch :stderr
-
-        self.stdout_thread = Thread.new do
-          stdout_stream.each_line { |line| queue << Events::Stdout.new(line) }
-          queue << :stdout_thread_finished
+        self.finish_criteria = FinishCriteria.new
+        self.queue           = Queue.new
+        event_stream         = streams.fetch :events
+        stdout_stream        = streams.fetch :stdout
+        stderr_stream        = streams.fetch :stderr
+
+        Thread.new do
+          begin
+            stdout_stream.each_line { |line| queue << Events::Stdout.new(value: line) }
+            queue << Events::StdoutClosed.new(side: :producer)
+          rescue IOError
+            queue << Events::StdoutClosed.new(side: :consumer)
+          ensure
+            queue << lambda { finish_criteria.stdout_thread_finished! }
+          end
         end
 
-        self.stderr_thread = Thread.new do
-          stderr_stream.each_line { |line| queue << Events::Stderr.new(line) }
-          queue << :stderr_thread_finished
+        Thread.new do
+          begin
+            stderr_stream.each_line { |line| queue << Events::Stderr.new(value: line) }
+            queue << Events::StderrClosed.new(side: :producer)
+          rescue IOError
+            queue << Events::StderrClosed.new(side: :consumer)
+          ensure
+            queue << lambda { finish_criteria.stderr_thread_finished! }
+          end
         end
 
-        self.event_thread = Thread.new do
-          begin loop do
-                   break unless line = event_stream.gets
-                   event = event_for line
-                   queue << event
-                 end
-          rescue IOError; queue << WtfWhoClosedMyShit.new("Our end of the pipe was closed!")
-          rescue SeeingIsBelievingError; queue << $!
-          ensure queue << :event_thread_finished
+        Thread.new do
+          begin
+            event_stream.each_line { |line| queue << line }
+            queue << Events::EventStreamClosed.new(side: :producer)
+          rescue IOError
+            queue << Events::EventStreamClosed.new(side: :consumer)
+          ensure
+            queue << lambda { finish_criteria.event_thread_finished! }
           end
         end
       end
@@ -46,42 +91,54 @@ class SeeingIsBelieving
 
       def each
         return to_enum :each unless block_given?
-        loop { yield call(1) }
-      rescue NoMoreInput
+        yield call 1 until @finished
+      end
+
+      # NOTE: Note it's probably a bad plan to call this method
+      # from within the same thread as the consumer, because if it
+      # blocks, who will remove items from the queue?
+      def process_exitstatus(status)
+        queue << Events::Exitstatus.new(value: status)
+        queue << lambda {
+          finish_criteria.process_exited!
+        }
       end
 
       private
 
-      attr_accessor :queue, :event_stream, :finished_threads
-      attr_accessor :event_thread, :stdout_thread, :stderr_thread
+      attr_accessor :queue, :finish_criteria
 
       def next_event
-        raise NoMoreInput if @no_more_input
-
-        case event = queue.shift
-        when Symbol
-          @no_more_input = true if finished_threads.push(event).size == 3
+        raise NoMoreEvents if @finished
+        case element = queue.shift
+        when String
+          event_for element
+        when Proc
+          element.call
+          if finish_criteria.satisfied?
+            queue << Events::Finished.new
+          end
           next_event
-        when SeeingIsBelievingError
-          raise event
+        when Events::Finished
+          @finished = true
+          element
+        when Event
+          element
         else
-          event
+          p "WAT: #{element.inspect}"
         end
       end
 
       def extract_token(line)
         event_name = line[/[^ ]+/]
-        line.sub! /^\s*[^ ]+\s*/, ''
+        line.sub!(/^\s*[^ ]+\s*/, '')
         event_name
       end
 
-      # for a consideration of many different ways of doing this, see 5633064
+      # For a consideration of many different ways of passing the message, see 5633064
       def extract_string(line)
-        Marshal.load extract_token(line).unpack('m0').first
-      end
-
-      def tokenize(line)
-        line.split(' ')
+        str = Marshal.load extract_token(line).unpack('m0').first
+        Consumer.fix_encoding(str)
       end
 
       def event_for(original_line)
@@ -92,38 +149,31 @@ class SeeingIsBelieving
           line_number = extract_token(line).to_i
           type        = extract_token(line).intern
           inspected   = extract_string(line)
-          Events::LineResult.new(type, line_number, inspected)
+          Events::LineResult.new(type: type, line_number: line_number, inspected: inspected)
         when :maxed_result
           line_number = extract_token(line).to_i
           type        = extract_token(line).intern
-          Events::UnrecordedResult.new(type, line_number)
+          Events::ResultsTruncated.new(type: type, line_number: line_number)
         when :exception
-          Events::Exception.new(-1, '', '', []).tap do |exception|
-            loop do
-              line = event_stream.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
+          Events::Exception.new \
+            line_number: extract_token(line).to_i,
+            class_name:  extract_string(line),
+            message:     extract_string(line),
+            backtrace:   extract_token(line).to_i.times.map { extract_string line }
         when :max_line_captures
           token = extract_token(line)
           value = token =~ /infinity/i ? Float::INFINITY : token.to_i
-          Events::MaxLineCaptures.new(value)
-        when :exitstatus
-          Events::Exitstatus.new(extract_token(line).to_i)
+          Events::MaxLineCaptures.new(value: value)
         when :num_lines
-          Events::NumLines.new(extract_token(line).to_i)
+          Events::NumLines.new(value: extract_token(line).to_i)
         when :sib_version
-          Events::SiBVersion.new(extract_string line)
+          Events::SiBVersion.new(value: extract_string(line))
         when :ruby_version
-          Events::RubyVersion.new(extract_string line)
+          Events::RubyVersion.new(value: extract_string(line))
         when :filename
-          Events::Filename.new(extract_string line)
+          Events::Filename.new(value: extract_string(line))
+        when :exec
+          Events::Exec.new(args: extract_string(line))
         else
           raise UnknownEvent, original_line.inspect
         end