seeing_is_believing 3.1.1 → 3.2.0

data/lib/seeing_is_believing/event_stream/handlers/debug.rb

@@ -1,6 +1,10 @@
 class SeeingIsBelieving
   module EventStream
     module Handlers
+      # Even though the debugger can be disabled, which would push the decision of
+      # whether to report or not into the debugger where it belongs, you should still
+      # avoid using this class if you don't need it since it is expensive and there
+      # could be tens of millions of events, eg https://github.com/JoshCheek/seeing_is_believing/issues/12
       class Debug
         def initialize(debugger, handler)
           @debugger   = debugger
@@ -22,7 +26,7 @@ class SeeingIsBelieving
         attr_reader :debugger, :handler
 
         def finish
-          @debugger.context("EVENTS:") { @seen }
+          @debugger.context("EVENTS") { @seen }
         end
 
         def observe(event)

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -9,7 +9,7 @@ class SeeingIsBelieving
     class Producer
       module NullQueue
         extend self
-        Queue.instance_methods.each do |name|
+        Queue.instance_methods(false).each do |name|
           define_method(name) { |*| }
         end
       end

data/lib/seeing_is_believing/hard_core_ensure.rb

@@ -25,6 +25,7 @@ class SeeingIsBelieving
         invoke_ensure
         Process.kill 'INT', $$
       end
+      trap 'INT', old_handler if ignore_interrupt? old_handler
     end
 
     def invoke_code
@@ -48,5 +49,10 @@ class SeeingIsBelieving
         raise ArgumentError, "Unknown keys: #{unknown_keys.map(&:inspect).join(', ')}"
       end
     end
+
+    def ignore_interrupt?(interrupt_handler)
+      # any handler that ignores gets normalized to IGNORE
+      interrupt_handler == 'IGNORE'
+    end
   end
 end

data/lib/seeing_is_believing/result.rb

@@ -3,14 +3,17 @@ class SeeingIsBelieving
     include Enumerable
     RecordedException = Struct.new :line_number, :class_name, :message, :backtrace
 
-    attr_accessor :stdout, :stderr, :exitstatus, :max_line_captures, :exception, :num_lines, :sib_version, :ruby_version, :filename, :timeout_seconds
+    attr_accessor :stdout, :stderr, :exitstatus, :max_line_captures, :exceptions, :num_lines, :sib_version, :ruby_version, :filename, :timeout_seconds
 
-    def initialize
-      self.stdout = ''
-      self.stderr = ''
+    def has_exception?
+      exceptions.any?
     end
 
-    alias has_exception? exception
+    def initialize
+      self.stdout     = ''
+      self.stderr     = ''
+      self.exceptions = []
+    end
 
     def has_stdout?
       stdout && !stdout.empty?
@@ -30,7 +33,11 @@ class SeeingIsBelieving
     end
 
     def record_exception(line_number, exception_class, exception_message, exception_backtrace)
-      self.exception = RecordedException.new line_number, exception_class, exception_message, exception_backtrace
+      self.exceptions << RecordedException.new(line_number, exception_class, exception_message, exception_backtrace)
+    end
+
+    def exception
+      exceptions.first
     end
 
     def [](line_number, type=:inspect)
@@ -47,17 +54,13 @@ class SeeingIsBelieving
     end
 
     def as_json
-      ex = has_exception? && {
-        line_number_in_this_file: exception.line_number,
-        class_name:               exception.class_name,
-        message:                  exception.message,
-        backtrace:                exception.backtrace,
-      }
-
+      # We have both an exception and a list of exceptions because multiple exceptions
+      # weren't added until #85, and I don't want to break backwards compatibility right now.
       { stdout:     stdout,
         stderr:     stderr,
         exitstatus: exitstatus,
-        exception:  ex,
+        exception:  exception_json(exception),
+        exceptions: exceptions.map { |e| exception_json e },
         lines:      each.with_object(Hash.new)
                         .with_index(1) { |(result, hash), line_number| hash[line_number] = result },
       }
@@ -73,5 +76,14 @@ class SeeingIsBelieving
     def results
       @results ||= Hash.new
     end
+
+    def exception_json(exception)
+      return nil unless exception
+      { line_number_in_this_file: exception.line_number,
+        class_name:               exception.class_name,
+        message:                  exception.message,
+        backtrace:                exception.backtrace,
+      }
+    end
   end
 end

data/lib/seeing_is_believing/safe.rb

@@ -21,7 +21,6 @@ class SeeingIsBelieving
     refine Symbol do
       alias ==      ==
       alias to_s    to_s
-      alias inspect inspect
     end
 
     refine Symbol.singleton_class do
@@ -35,6 +34,12 @@ class SeeingIsBelieving
       alias to_str to_str
     end
 
+    # in 2.4 we should use Integer instead, but it's not obvious to me how
+    # to detect this. eg defined?(Fixnum) returns "constant". Accessing it
+    # leads to a warning, but SiB turns warnings off so you don't see it.
+    # So.... for now, it incidentally doesn't do anything annoying, but would
+    # be good to figure out something better (eg if we ever wanted to allow the
+    # user to decide whether warnings should display or not)
     refine Fixnum do
       alias to_s to_s
       alias next next

data/lib/seeing_is_believing/the_matrix.rb

@@ -1,11 +1,21 @@
 require_relative 'safe'
 require_relative 'version'
 require_relative 'event_stream/producer'
+require 'socket'
+require 'timeout'
 
 using SeeingIsBelieving::Safe
 
 sib_vars     = Marshal.load ENV["SIB_VARIABLES.MARSHAL.B64"].unpack('m0').first
-event_stream = IO.open sib_vars.fetch(:event_stream_fd), "w"
+event_stream = Timeout.timeout(1) do
+  begin
+    Socket.tcp("localhost", sib_vars.fetch(:event_stream_port))
+  rescue Errno::ECONNREFUSED
+    sleep 0.1
+    retry
+  end
+end
+
 $SiB = SeeingIsBelieving::EventStream::Producer.new(event_stream)
 $SiB.record_ruby_version      RUBY_VERSION
 $SiB.record_sib_version       SeeingIsBelieving::VERSION
@@ -14,13 +24,16 @@ $SiB.record_num_lines         sib_vars.fetch(:num_lines)
 $SiB.record_max_line_captures sib_vars.fetch(:max_line_captures)
 
 STDOUT.sync = true
+STDOUT.binmode
+STDERR.binmode
+STDIN.set_encoding "utf-8"
 stdout, stderr = STDOUT, STDERR
 
 finish = lambda do
   $SiB.finish!
   event_stream.close
-  stdout.flush
-  stderr.flush
+  stdout.flush unless stdout.closed?
+  stderr.flush unless stderr.closed?
 end
 
 real_exec      = method :exec
@@ -31,7 +44,6 @@ fork_defn      = lambda do |*args|
   $SiB.send :forking_occurred_and_you_are_the_child, event_stream unless result
   result
 end
-
 Kernel.module_eval do
   private
 

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.1.1'
+  VERSION = '3.2.0'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -102,7 +102,7 @@ class SeeingIsBelieving
     def wrap_recursive(ast)
       return wrappings unless ast.kind_of? ::AST::Node
       case ast.type
-      when :args, :redo, :retry, :alias, :undef, :null_node
+      when :args, :redo, :retry, :alias, :undef, :null_node, :iflipflop, :eflipflop
         # no op
       when :defs, :module
         add_to_wrappings ast

data/lib/seeing_is_believing.rb

@@ -16,7 +16,7 @@ class SeeingIsBelieving
     attribute(:encoding)          { nil }
     attribute(:stdin)             { "" }
     attribute(:require_files)     { ['seeing_is_believing/the_matrix'] }
-    attribute(:load_path_dirs)    { [File.expand_path('..', __FILE__)] }
+    attribute(:load_path_dirs)    { [File.realpath(__dir__)] }
     attribute(:timeout_seconds)   { 0 }
     attribute(:debugger)          { Debugger::Null }
     attribute(:max_line_captures) { Float::INFINITY }
@@ -36,7 +36,7 @@ class SeeingIsBelieving
 
   def call
     @memoized_result ||= Dir.mktmpdir("seeing_is_believing_temp_dir") { |dir|
-      filename = options.filename || File.join(dir, 'program.rb')
+      filename    = options.filename || File.join(dir, 'program.rb')
       new_program = options.rewrite_code.call @program
 
       options.debugger.context("REWRITTEN PROGRAM") { new_program }
@@ -44,7 +44,7 @@ class SeeingIsBelieving
       EvaluateByMovingFiles.call \
         new_program,
         filename,
-        event_handler:     debugging_handler,
+        event_handler:     event_handler(options.debugger, options.event_handler),
         provided_input:    options.stdin,
         require_files:     options.require_files,
         load_path_dirs:    options.load_path_dirs,
@@ -58,12 +58,9 @@ class SeeingIsBelieving
 
   private
 
-  # Even though the debugger can be disabled,
-  # Handlers::Debug is somewhat expensive, and there could be tens of millions of calls
-  # e.g. https://github.com/JoshCheek/seeing_is_believing/issues/12
-  # so just skip it in this case
-  def debugging_handler
-    return options.event_handler unless options.debugger.enabled?
-    EventStream::Handlers::Debug.new options.debugger, options.event_handler
+  # If we need debugging, wrap a debugging handler around the current handler
+  def event_handler(debugger, current_handler)
+    return current_handler unless debugger.enabled?
+    EventStream::Handlers::Debug.new debugger, current_handler
   end
 end

data/seeing_is_believing.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$:.push File.realpath("lib", __dir__)
 require "seeing_is_believing/version"
 
 Gem::Specification.new do |s|
@@ -19,14 +19,15 @@ 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",   ">= 2.3.0.7", "< 3.0"
+  s.add_dependency             "parser",      ">= 2.3.0.7", "< 3.0"
+  s.add_dependency             "childprocess","~> 0.5.9"
 
-  s.add_development_dependency "haiti",    ">= 0.1", "< 0.3"
-  s.add_development_dependency "rake",     "~> 11.2.2"
-  s.add_development_dependency "mrspec",   "~>  0.3.1"
-  s.add_development_dependency "rspec",    "~>  3.5"
-  s.add_development_dependency "cucumber", "~>  2.4"
-  s.add_development_dependency "ichannel", "~>  8.1"
+  s.add_development_dependency "haiti",       ">= 0.1", "< 0.3"
+  s.add_development_dependency "rake",        "~> 11.2.2"
+  s.add_development_dependency "mrspec",      "~>  0.3.1"
+  s.add_development_dependency "rspec",       "~>  3.5"
+  s.add_development_dependency "cucumber",    "~>  2.4"
+  s.add_development_dependency "ripper-tags", "~>  0.3"
 
   s.post_install_message = <<'Omg, frogs <3'.gsub(/(gg+)/) { |capture| "\e[32m#{capture.gsub 'g', '.'}\e[0m" }.gsub("brown", "\e[33m").gsub("off", "\e[0m")
               .7

data/spec/binary/config_spec.rb

@@ -69,6 +69,21 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
     end
   end
 
+  shared_examples 'it can extract its argument from conjoined shortflags' do |flag, arg, verify|
+    it 'can be the only item (the argument has no space)' do
+      instance_exec parse(%W[-#{flag}#{arg}]), &verify
+
+      # sanity check the verifier by giving it someting it should fail on
+      expect { instance_exec parse(%W[-#{flag}#{arg}X]), &verify }.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+
+    it 'can appear after another flag' do
+      expect(       parse(%W[-#{flag}#{arg}]  )[:debug]).to eq false
+      expect(       parse(%W[-g#{flag}#{arg}] )[:debug]).to eq true
+      instance_exec parse(%W[-g#{flag}#{arg}] ), &verify
+    end
+  end
+
   describe 'parsing from args' do
     it 'does not mutate the input array' do
       ary = ['a']
@@ -186,6 +201,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse(%w[-a   ])).to have_error /-a/
         expect(parse(%w[--as ])).to have_error /--as/
       end
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'a', 'some-filename.whatever', -> parsed do
+        expect(parsed.lib_options.filename).to eq 'some-filename.whatever'
+      end
     end
 
 
@@ -200,6 +219,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
 
       it_behaves_like 'it requires a positive int argument', ['-D', '--result-length']
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'D', '12', -> parsed do
+        expect(parsed.annotator_options.max_result_length).to eq 12
+      end
     end
 
     describe 'annotator_options.max_line_length' do
@@ -213,6 +236,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
 
       it_behaves_like 'it requires a positive int argument', ['-d', '--line-length']
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'd', '12', -> parsed do
+        expect(parsed.annotator_options.max_line_length).to eq 12
+      end
     end
 
     describe 'lib_options.require_files' do
@@ -233,6 +260,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       specify '-r and --require add the filename into the result array' do
         expect(parse(%w[-r f1 --require f2]).lib_options.require_files).to eq [matrix_file, 'f1', 'f2']
       end
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'r', 'filename', -> parsed do
+        expect(parsed.lib_options.require_files).to include 'filename'
+      end
     end
 
     describe 'print_help? and help_screen' do
@@ -284,10 +315,14 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse(['--program', 'body'])).to_not have_error /--program/
         expect(parse(['--program'        ])).to     have_error /--program/
       end
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'e', 'some program', -> parsed do
+        expect(parsed.body).to eq 'some program'
+      end
     end
 
     describe'lib_options.load_path_dirs' do
-      let(:lib_path) { File.expand_path '../../../lib', __FILE__ }
+      let(:lib_path) { File.realpath '../../lib', __dir__ }
 
       it 'defaults to sib\'s lib path' do
         expect(parse([]).lib_options.load_path_dirs).to eq [lib_path]
@@ -302,6 +337,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse(['-I'])).to have_error /-I\b/
         expect(parse(['--load-path'])).to have_error /--load-path\b/
       end
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'I', 'added-path', -> parsed do
+        expect(parsed.lib_options.load_path_dirs).to include 'added-path'
+      end
     end
 
     describe 'lib_options.encoding' do
@@ -326,6 +365,16 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse(['-K'])).to have_error /-K/
         expect(parse(['--encoding'])).to have_error /--encoding/
       end
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'K', 'u', -> parsed do
+        expect(parsed.lib_options.encoding).to eq 'u'
+      end
+
+      it 'is deprecated' do
+        assert_deprecated '--encoding', 'u'
+        assert_deprecated '-K', 'u'
+        assert_deprecated '-Ku'
+      end
     end
 
     describe '.print_cleaned?' do
@@ -368,6 +417,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
 
       it_behaves_like 'it requires a non-negative float or int', ['-t', '--timeout-seconds', '--timeout']
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 't', '123', -> parsed do
+        expect(parsed.lib_options.timeout_seconds).to eq 123
+      end
     end
 
     describe 'annotator_options.alignment_strategy' do
@@ -403,6 +456,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse(['-s', 'file'])).to_not have_error '-s'
         expect(parse(['-s', 'unknown'])).to have_error '-s', 'expected one of'
       end
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 's', 'file', -> parsed do
+        expect(parsed.annotator_options.alignment_strategy).to eq align_file
+      end
     end
 
     describe 'inherit_exitstatus?' do
@@ -499,6 +556,10 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
 
       it_behaves_like 'it requires a positive int argument', ['-n', '--max-line-captures', '--number-of-captures']
+
+      it_behaves_like 'it can extract its argument from conjoined shortflags', 'n', '12', -> parsed do
+        expect(parsed.lib_options.max_line_captures).to eq 12
+      end
     end
 
     describe 'result_as_json?' do
@@ -580,7 +641,7 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
 
   describe '.finalize' do
     let(:stdin_data) { 'stdin data' }
-    let(:stdin)      { object_double $stdin, read: stdin_data }
+    let(:stdin)      { object_double $stdin, read: stdin_data, set_encoding: nil }
     let(:stdout)     { object_double $stdout }
     let(:stderr)     { object_double $stderr, :tty? => true }
 
@@ -592,7 +653,7 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
     before do
       allow(file_class).to receive(:exist?).with(existing_filename).and_return(true)
       allow(file_class).to receive(:exist?).with(nonexisting_filename).and_return(false)
-      allow(file_class).to receive(:read).with(existing_filename).and_return(file_body)
+      allow(file_class).to receive(:read).with(existing_filename, any_args).and_return(file_body)
     end
 
     def call(attrs={})
@@ -715,7 +776,7 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
 
       context 'when debug? is a string' do
-        let(:proving_grounds_dir) { File.expand_path '../../../proving_grounds', __FILE__  }
+        let(:proving_grounds_dir) { File.realdirpath '../../proving_grounds', __dir__  }
         let(:path)                { File.join proving_grounds_dir, 'test.log' }
         before                    { Dir.mkdir proving_grounds_dir unless Dir.exist? proving_grounds_dir }
 

data/spec/binary/engine_spec.rb

@@ -14,7 +14,7 @@ class SeeingIsBelieving
       end
 
       def assert_must_evaluate(message)
-        engine = call ''
+        engine = call '1+1'
         expect { engine.__send__ message }.to raise_error MustEvaluateFirst, /#{message}/
         engine.evaluate!
         engine.__send__ message

data/spec/evaluate_by_moving_files_spec.rb

@@ -4,9 +4,10 @@ require 'spec_helper'
 require 'seeing_is_believing/evaluate_by_moving_files'
 require 'seeing_is_believing/event_stream/handlers/update_result'
 require 'fileutils'
+require 'childprocess'
 
 RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
-  let(:filedir)  { File.expand_path '../../proving_grounds', __FILE__ }
+  let(:filedir)  { File.realdirpath '../proving_grounds', __dir__ }
   let(:filename) { File.join filedir, 'some_filename' }
 
   before { FileUtils.mkdir_p filedir }
@@ -143,15 +144,40 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'can set a timeout, which interrupts the process group and then waits for the events to finish' do
-    expect(Timeout).to receive(:timeout).with(123).and_raise(Timeout::Error)
-    expect(Process).to receive(:kill).with("-INT", an_instance_of(Fixnum))
-    result = invoke 'p gets', timeout_seconds: 123
+    pre    = Time.now
+    result = invoke <<-RUBY, timeout_seconds: 0.5
+    child_pid = spawn 'ruby', '-e', 'sleep' # child makes a grandchild which sleeps
+    puts Process.pid, child_pid             # print ids so we can check they got killed
+    sleep                                   # child sleeps
+    RUBY
+    post   = Time.now
     expect(result.timeout?).to eq true
-    expect(result.timeout_seconds).to eq 123
+    expect(result.timeout_seconds).to eq 0.5
+    expect(post - pre).to be > 0.5
+    child_id, grandchild_id, *rest = result.stdout.lines
+    expect(child_id).to match /^\d+$/
+    expect(grandchild_id).to match /^\d+$/
+    expect(rest).to be_empty
+    expect { Process.wait child_id.to_i      } .to raise_error /no.*processes/i
+    expect { Process.wait grandchild_id.to_i } .to raise_error /no.*processes/i
   end
 
   it 'raises an ArgumentError if given arguments it doesn\'t know' do
     expect { invoke '1', watisthis: :idontknow }
       .to raise_error ArgumentError, /watisthis/
   end
+
+  it 'doesn\'t explode or do anything else obnoxious when the input stream is closed' do
+    infinite_string = Object.new
+    def infinite_string.each_char
+      loop { yield 'c' }
+    end
+    result = nil
+    expect {
+      result = invoke '$stdin.close', provided_input: infinite_string
+    }.to_not output.to_stderr
+    expect(result.exitstatus).to eq 0
+    expect(result.stderr).to be_empty
+    expect(result.stdout).to be_empty
+  end
 end

data/spec/event_stream_spec.rb

@@ -24,9 +24,9 @@ module SeeingIsBelieving::EventStream
     end
 
     before do
-      self.eventstream_consumer, self.eventstream_producer = IO.pipe
-      self.stdout_consumer,      self.stdout_producer      = IO.pipe
-      self.stderr_consumer,      self.stderr_producer      = IO.pipe
+      self.eventstream_consumer, self.eventstream_producer = IO.pipe("utf-8")
+      self.stdout_consumer,      self.stdout_producer      = IO.pipe("utf-8")
+      self.stderr_consumer,      self.stderr_producer      = IO.pipe("utf-8")
 
       self.producer = SeeingIsBelieving::EventStream::Producer.new eventstream_producer
       self.consumer = SeeingIsBelieving::EventStream::Consumer.new \
@@ -42,9 +42,8 @@ module SeeingIsBelieving::EventStream
 
     describe 'emitting an event' do
       def has_message?(io)
-        io.read_nonblock(1)  # ~> IO::EAGAINWaitReadable: Resource temporarily unavailable - read would block
-      rescue Errno::EAGAIN
-        return false
+        readables, * = IO.select([io], [], [], 0.1) # 0.1 is the timeout
+        readables.to_a.any? # when it times out, IO.select may return nil...
       end
 
       it 'writes its events to the event stream' do
@@ -592,6 +591,15 @@ module SeeingIsBelieving::EventStream
         expect(consumer.call).to eq Events::Exitstatus.new(value: 92)
       end
 
+      it 'translates missing statusses to 1 (eg this happens on my machine when the program segfaults, see #100)' do
+        # I'm not totally sure this is the right thing for it to do, but a segfault is the only way
+        # I know of to invoke this situation, and a segfault is printable, so until I get some info
+        # that proves this is the wrong thing to do, we're just going to give it a normal exit status
+        # since that's the easiest thing to do, and it's more correct in this one case.
+        consumer.process_exitstatus nil
+        expect(consumer.call).to eq Events::Exitstatus.new(value: 1)
+      end
+
       it 'emits a Finished event when all streams are closed and it has an exit status' do
         consumer.process_exitstatus 1
         close_streams eventstream_producer, stdout_producer, stderr_producer