seeing_is_believing 3.0.0.beta.2 → 3.0.0.beta.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 981bfb703701767923dee2010cd2073ec901e20f
-  data.tar.gz: 0eaa0290fac0e7b0b312196371507f717b2ad1d7
+  metadata.gz: d2e468be6e5df6cd6e01b6c6d000e204adea080f
+  data.tar.gz: 27401d23d03170455703d30a285e8a55726c0192
 SHA512:
-  metadata.gz: 019b0ac6587cb94c98bc9e916daa49f8b21e6eba166a3a6c5e930de573ecce274004f11de8cd47e366af46c4da881376b05c4ef4d3a8a43a5e0c614517a53d75
-  data.tar.gz: d515e9959c12741755f0ff298a5f571d8860290a15f3548e3386ae7ef8b4b9c0364ccac1c7a7816a771fc9a100746f813e259dce2cac943d01c6f8d70510dc1d
+  metadata.gz: 572bad143fd60f08c04b43289143f46ade1121300b6073830107ce183aef58741bd1acd3b1d75544d2af878df4802346e2e1a921b5e60464b7eddfb69498e4f5
+  data.tar.gz: 858d05b38816d4d99768985bf0ad16ebc82dd51309f1e5444ff2ce475e501e038b50e4b017dc1f2c16126e20eaafe32a999f85d835fe7f996b13765238be1135

data/features/errors.feature

@@ -91,10 +91,3 @@ Feature: Running the binary unsuccessfully
     def m() m end  # ~> SystemStackError: stack level too deep
     m
     """
-
-  Scenario: Total Fucking Failure
-    Given the file "sib_will_utterly_die.rb" "__TOTAL_FUCKING_FAILURE__"
-    When I run "seeing_is_believing sib_will_utterly_die.rb"
-    Then stderr is not empty
-    And the exit status is 2
-    And stdout is empty

data/features/flags.feature

@@ -385,7 +385,7 @@ Feature: Using flags
   Scenario: --inherit-exit-status in an at_exit block
     Given the file "exit_status_in_at_exit_block.rb" "at_exit { exit 10 }"
     When I run "seeing_is_believing exit_status_in_at_exit_block.rb"
-    Then the exit status is 0
+    Then the exit status is 1
     When I run "seeing_is_believing --inherit-exit-status exit_status_in_at_exit_block.rb"
     Then the exit status is 10
 

data/features/regression.feature

@@ -344,6 +344,7 @@ Feature:
     # !> stderr gets past it b/c of dumb ruby bug
     """
 
+
   Scenario: Incorrect wrapping in some programs
     Given the file "incorrect_wrapping.rb":
     """
@@ -391,3 +392,25 @@ Feature:
       end         # => {{method_result :!}}
     end
     """
+
+
+  Scenario: Is cool with exceptions raised in at_exit hooks
+    Given the file "at_exit_exception_direct.rb" "at_exit { raise 'zomg' }"
+    When I run "seeing_is_believing at_exit_exception_direct.rb"
+    Then stderr is empty
+    And the exit status is 1
+    And stdout includes "at_exit { raise 'zomg' }  # ~>"
+    And stdout includes "RuntimeError"
+    And stdout includes "zomg"
+    And stdout does not include "the_matrix"
+
+
+  Scenario: Is cool with exceptions raised in at_exit exceptions by code not in the running file (e.g. SimpleCov)
+    Given the file "at_exit_exception_indirect1.rb" "at_exit { raise 'zomg' }"
+    Given the file "at_exit_exception_indirect2.rb" "require_relative 'at_exit_exception_indirect1'"
+    When I run "seeing_is_believing at_exit_exception_indirect2.rb"
+    Then stderr is empty
+    And the exit status is 1
+    And stdout includes "require_relative 'at_exit_exception_indirect1'  # => true"
+    And stdout includes "RuntimeError"
+    And stdout includes "zomg"

data/lib/seeing_is_believing.rb

@@ -30,31 +30,12 @@ class SeeingIsBelieving
   end
 
   def call
-    @memoized_result ||= begin
-      new_program = program_that_will_record_expressions
+    @memoized_result ||= Dir.mktmpdir("seeing_is_believing_temp_dir") { |dir|
+      filename    = @filename || File.join(dir, 'program.rb')
+      new_program = @record_expressions.call "#{@program.chomp}\n", filename, @number_of_captures
       @debugger.context("TRANSLATED PROGRAM") { new_program }
-      result = result_for new_program
-      @debugger.context("RESULT") { result.inspect }
-      result
-    end
-  end
-
-  private
-
-  def to_stream(string_or_stream)
-    return string_or_stream if string_or_stream.respond_to? :gets
-    StringIO.new string_or_stream
-  end
-
-  def program_that_will_record_expressions
-    @record_expressions.call "#{@program.chomp}\n", @number_of_captures
-  end
 
-  def result_for(program)
-    Dir.mktmpdir "seeing_is_believing_temp_dir" do |dir|
-      filename = @filename || File.join(dir, 'program.rb')
-
-      @evaluator.call program,
+      result = @evaluator.call new_program,
                       filename,
                       input_stream:       @stdin,
                       require:            @require,
@@ -63,6 +44,17 @@ class SeeingIsBelieving
                       timeout:            @timeout,
                       ruby_executable:    @ruby_executable,
                       debugger:           @debugger
-    end
+
+      @debugger.context("RESULT") { result.inspect }
+
+      result
+    }
+  end
+
+  private
+
+  def to_stream(string_or_stream)
+    return string_or_stream if string_or_stream.respond_to? :gets
+    StringIO.new string_or_stream
   end
 end

data/lib/seeing_is_believing/binary.rb

@@ -79,7 +79,7 @@ class SeeingIsBelieving
 
       if options.inherit_exit_status?
         results.exitstatus
-      elsif results.has_exception?
+      elsif results.has_exception? && results.exitstatus != 0 # e.g. `exit 0` raises SystemExit but isn't an error
         DISPLAYABLE_ERROR_STATUS
       else
         SUCCESS_STATUS

data/lib/seeing_is_believing/binary/annotate_xmpfilter_style.rb

@@ -9,7 +9,7 @@ class SeeingIsBelieving
       end
 
       def self.expression_wrapper(markers, marker_regexes)
-        -> program, number_of_captures {
+        lambda do |program, filename, number_of_captures|
           inspect_linenos = []
           pp_linenos      = []
           Code.new(program).inline_comments.each do |c|
@@ -19,12 +19,13 @@ class SeeingIsBelieving
           end
 
           InspectExpressions.call program,
+                                  filename,
                                   number_of_captures,
                                   before_all: -> {
                                     # TODO: this is duplicated with the InspectExpressions class
                                     number_of_captures_as_str = number_of_captures.inspect
                                     number_of_captures_as_str = 'Float::INFINITY' if number_of_captures == Float::INFINITY
-                                    "begin; require 'pp'; $SiB.max_line_captures = #{number_of_captures_as_str}; $SiB.num_lines = #{program.lines.count}; "
+                                    "require 'pp'; $SiB.filename = #{filename.inspect}; $SiB.max_line_captures = #{number_of_captures_as_str}; $SiB.num_lines = #{program.lines.count}; "
                                   },
                                   after_each: -> line_number {
                                     should_inspect = inspect_linenos.include?(line_number)
@@ -38,7 +39,7 @@ class SeeingIsBelieving
                                     else                                   ")"
                                     end
                                   }
-        }
+        end
       end
 
       def self.call(body, results, options)

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -24,7 +24,6 @@ require 'seeing_is_believing/event_stream/update_result'
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
-
     def self.call(*args)
       new(*args).call
     end
@@ -51,10 +50,9 @@ class SeeingIsBelieving
           write_program_to_file
           begin
             evaluate_file
-            fail if result.bug_in_sib?
             result
           rescue Exception => error
-            error = wrap_error error if error_implies_bug_in_sib? error
+            error = wrap_error error unless error.kind_of? Timeout::Error
             raise error
           end
         },
@@ -75,10 +73,6 @@ class SeeingIsBelieving
 
     attr_accessor :stdout, :stderr, :exitstatus
 
-    def error_implies_bug_in_sib?(error)
-      not error.kind_of? Timeout::Error
-    end
-
     def we_will_not_overwrite_existing_tempfile!
       raise TempFileAlreadyExists.new(filename, temp_filename) if File.exist? temp_filename
     end
@@ -110,7 +104,7 @@ class SeeingIsBelieving
         }
 
         # consume events
-        self.result = Result.new
+        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(process_stdout)
                                .each { |event| EventStream::UpdateResult.call result, event }

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -89,8 +89,6 @@ class SeeingIsBelieving
           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

data/lib/seeing_is_believing/event_stream/events.rb

@@ -5,7 +5,6 @@ class SeeingIsBelieving
       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)

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -3,11 +3,11 @@ class SeeingIsBelieving
   module EventStream
     require 'thread'
     class Producer
-      attr_accessor :exitstatus, :bug_in_sib, :max_line_captures, :num_lines
+      attr_accessor :exitstatus, :max_line_captures, :num_lines, :filename
 
       def initialize(resultstream)
+        self.filename          = nil
         self.exitstatus        = 0
-        self.bug_in_sib        = false
         self.max_line_captures = Float::INFINITY
         self.num_lines         = 0
         self.recorded_results  = []
@@ -15,6 +15,7 @@ class SeeingIsBelieving
         self.producer_thread   = Thread.new do
           finish = "finish"
           begin
+            resultstream.sync = true
             loop do
               to_publish = queue.shift
               if to_publish == finish
@@ -26,14 +27,12 @@ class SeeingIsBelieving
             end
           rescue IOError, Errno::EPIPE
             loop { break if queue.shift == finish }
+          ensure
+            resultstream.flush rescue nil
           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')
@@ -70,7 +69,16 @@ class SeeingIsBelieving
       end
 
       def record_exception(line_number, exception)
-        self.num_lines = line_number if num_lines < line_number
+        self.exitstatus = (exception.kind_of?(SystemExit) ? exception.status : 1)
+        if line_number
+          self.num_lines = line_number if num_lines < line_number
+        elsif filename
+          begin
+            line_number = exception.backtrace.grep(/#{filename}/).first[/:\d+/][1..-1].to_i
+          rescue Exception
+          end
+        end
+        line_number ||= -1
         queue << "exception"
         queue << "  line_number #{line_number}"
         queue << "  class_name  #{to_string_token exception.class.name}"
@@ -90,7 +98,6 @@ class SeeingIsBelieving
       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}"

data/lib/seeing_is_believing/event_stream/update_result.rb

@@ -9,7 +9,6 @@ class SeeingIsBelieving
          when EventStream::Events::Exception        then result.record_exception event.line_number, event.class_name, event.message, event.backtrace
          when EventStream::Events::Stdout           then result.stdout             = event.value
          when EventStream::Events::Stderr           then result.stderr             = event.value
-         when EventStream::Events::BugInSiB         then result.bug_in_sib         = event.value
          when EventStream::Events::MaxLineCaptures  then result.number_of_captures = event.value
          when EventStream::Events::Exitstatus       then result.exitstatus         = event.value
          when EventStream::Events::NumLines         then result.num_lines          = event.value

data/lib/seeing_is_believing/inspect_expressions.rb

@@ -1,21 +1,14 @@
 require 'seeing_is_believing/wrap_expressions'
 class SeeingIsBelieving
   module InspectExpressions
-    def self.call(program, number_of_captures, options={})
+    def self.call(program, filename, number_of_captures, options={})
+      # TODO: much of this is duplicated in annotate_xmpfilter_stle
       number_of_captures_as_str = number_of_captures.inspect
       number_of_captures_as_str = 'Float::INFINITY' if number_of_captures == Float::INFINITY
 
       wrap_expressions_callbacks = {}
-      wrap_expressions_callbacks[:before_all]  = options.fetch :before_all,  -> { "begin; $SiB.max_line_captures = #{number_of_captures_as_str}; $SiB.num_lines = #{program.lines.count}; " }
-      wrap_expressions_callbacks[:after_all]   = options.fetch :after_all,   -> { ";rescue Exception;"\
-                                                                                     "lambda {"\
-                                                                                       "line_number = $!.backtrace.grep(/\#{__FILE__}/).first[/:\\d+/][1..-1].to_i;"\
-                                                                                       "$SiB.record_exception line_number, $!;"\
-                                                                                       "$SiB.exitstatus = 1;"\
-                                                                                       "$SiB.exitstatus = $!.status if $!.kind_of? SystemExit;"\
-                                                                                     "}.call;"\
-                                                                                   "end"
-                                                                              }
+      wrap_expressions_callbacks[:before_all]  = options.fetch :before_all,  -> { "$SiB.filename = #{filename.inspect}; $SiB.max_line_captures = #{number_of_captures_as_str}; $SiB.num_lines = #{program.lines.count}; " }
+      wrap_expressions_callbacks[:after_all]   = options.fetch :after_all,   -> { "" }
       wrap_expressions_callbacks[:before_each] = options.fetch :before_each, -> line_number { "(" }
       wrap_expressions_callbacks[:after_each]  = options.fetch :after_each,  -> line_number { ").tap { |v| $SiB.record_result(:inspect, #{line_number}, v) }" }
       WrapExpressions.call program, wrap_expressions_callbacks

data/lib/seeing_is_believing/result.rb

@@ -3,10 +3,9 @@ class SeeingIsBelieving
     include Enumerable
     RecordedException = Struct.new :line_number, :class_name, :message, :backtrace
 
-    attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib, :number_of_captures, :exception, :num_lines
+    attr_accessor :stdout, :stderr, :exitstatus, :number_of_captures, :exception, :num_lines
 
     alias has_exception? exception
-    alias bug_in_sib? bug_in_sib
 
     def has_stdout?
       stdout && !stdout.empty?

data/lib/seeing_is_believing/the_matrix.rb

@@ -8,33 +8,28 @@
 require_relative 'version'
 require_relative 'event_stream/producer'
 
-stdout_real_obj = STDOUT      # the real Ruby object, fake file descriptor
-stdout_real_fd  = STDOUT.dup  # duped Ruby object,    real file descriptor
-read_from_mock_out, write_to_mock_out = IO.pipe
-stdout_real_obj.reopen write_to_mock_out
+event_stream = STDOUT.dup  # duped Ruby object with the real file descriptor
+$SiB = SeeingIsBelieving::EventStream::Producer.new(event_stream)
 
-stderr_real_obj = STDERR
-stderr_real_fd  = STDERR.dup
-read_from_mock_err, write_to_mock_err = IO.pipe
-stderr_real_obj.reopen write_to_mock_err
+stdout = STDOUT # keep our own ref, b/c user could mess w/ constants and globals
+read_stdout, write_stdout = IO.pipe
+stdout.reopen(write_stdout)
 
-$SiB = SeeingIsBelieving::EventStream::Producer.new(stdout_real_fd)
+stderr = STDERR
+read_stderr, write_stderr = IO.pipe
+stderr.reopen(write_stderr)
 
 at_exit do
-  stdout_real_obj.reopen stdout_real_fd
-  write_to_mock_out.close unless write_to_mock_out.closed?
-  $SiB.record_stdout read_from_mock_out.read
-  read_from_mock_out.close
+  _, blackhole = IO.pipe
+  stdout.reopen(blackhole)
+  stderr.reopen(blackhole)
 
-  stderr_real_obj.reopen stderr_real_fd
-  write_to_mock_err.close unless write_to_mock_err.closed?
-  $SiB.record_stderr read_from_mock_err.read
-  read_from_mock_err.close
+  write_stdout.close unless write_stdout.closed?
+  $SiB.record_stdout read_stdout.read
 
-  $SiB.exitstatus ||= 0
-  $SiB.exitstatus   = 1         if $!
-  $SiB.exitstatus   = $!.status if $!.kind_of? SystemExit
-  $SiB.bug_in_sib   = $! && ! $!.kind_of?(SystemExit)
+  write_stderr.close unless write_stderr.closed?
+  $SiB.record_stderr read_stderr.read
 
+  $SiB.record_exception nil, $! if $!
   $SiB.finish!
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.0.0.beta.2'
+  VERSION = '3.0.0.beta.3'
 end

data/spec/evaluate_by_moving_files_spec.rb

@@ -101,7 +101,7 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     expect(result.stdout).to eq "123\n"
   end
 
-  it 'will set the encoding' do
+  it 'can set the encoding' do
     test = -> { expect(invoke('print "ç"', encoding: 'u').stdout).to eq "ç" }
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
       pending "Rubinius doesn't seem to use -Kx, but rather -U"
@@ -111,11 +111,16 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     end
   end
 
-  it 'if it fails, it prints some debugging information and raises an error' do
+  it 'if it fails, it tells the debugger some information and raises an error' do
     error_stream = StringIO.new
     evaluator = described_class.new 'raise "omg"', filename, debugger: SeeingIsBelieving::Debugger.new(stream: error_stream)
+    expect(evaluator).to receive(:evaluate_file).and_raise("whatevz")
     FileUtils.rm_f evaluator.temp_filename
     expect { evaluator.call }.to raise_error SeeingIsBelieving::BugInSib
     expect(error_stream.string).to include "Program could not be evaluated"
   end
+
+  it 'does not blow up on exceptions raised in at_exit blocks' do
+    expect { invoke 'at_exit { raise "zomg" }' }.to_not raise_error
+  end
 end

data/spec/event_stream_spec.rb

@@ -58,7 +58,7 @@ module SeeingIsBelieving::EventStream
 
       it 'raises NoMoreInput and marks itself finished once it receives the finish event' do
         producer.finish!
-        consumer.call 5
+        consumer.call 4
         expect { consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::NoMoreInput
         expect(consumer).to be_finished
       end
@@ -258,37 +258,118 @@ module SeeingIsBelieving::EventStream
     end
 
     describe 'exceptions' do
-      def assert_exception(recorded_exception, recorded_line_no, class_name, message_matcher, backtrace_index, backtrace_line)
+      def record_exception(linenum=nil, &raises_exception)
+        raises_exception.call
+      rescue Exception
+        producer.record_exception linenum, $!
+        return raises_exception.source_location.last
+      end
+
+      def assert_exception(recorded_exception, options={})
         expect(recorded_exception).to be_a_kind_of Events::Exception
-        expect(recorded_exception.line_number).to eq recorded_line_no
-        expect(recorded_exception.class_name).to  eq class_name
-        expect(recorded_exception.message).to match message_matcher
+        expect(recorded_exception.line_number).to eq    options[:recorded_line_no]
+        expect(recorded_exception.class_name ).to match options[:class_name_matcher] if options[:class_name_matcher]
+        expect(recorded_exception.message    ).to match options[:message_matcher]    if options[:message_matcher]
 
         backtrace = recorded_exception.backtrace
         expect(backtrace).to be_a_kind_of Array
         expect(backtrace).to be_all { |frame| String === frame }
-        frame = backtrace[backtrace_index]
-        expect(frame).to match __FILE__
-        expect(frame).to match /\b#{backtrace_line}\b/
+        frame = backtrace[options[:backtrace_index]||0]
+        expect(frame).to match /(^|\b)#{options[:backtrace_filename]}(\b|$)/ if options[:backtrace_filename]
+        expect(frame).to match /(^|\b)#{options[:backtrace_line]}(\b|$)/     if options[:backtrace_line]
       end
 
       it 'emits the line_number, an escaped class_name, an escaped message, and escaped backtrace' do
-        begin
-          raise ZeroDivisionError, 'omg'
-        rescue
-          producer.record_exception 12, $!
-        end
-        assert_exception consumer.call, 12, 'ZeroDivisionError', /\Aomg\Z/, 0, __LINE__-4
+        backtrace_line = record_exception(12) { raise ZeroDivisionError, 'omg' }
+        assert_exception consumer.call,
+                         recorded_line_no:   12,
+                         class_name_matcher: /^ZeroDivisionError$/,
+                         message_matcher:    /\Aomg\Z/,
+                         backtrace_index:    0,
+                         backtrace_line:     backtrace_line,
+                         backtrace_filename: __FILE__
       end
 
       example 'Example: Common edge case: name error' do
-        begin
-          not_a_local_or_meth
-        rescue
-          producer.record_exception 99, $!
+        backtrace_line  = record_exception(99) { not_a_local_or_meth }
+        backtrace_frame = 1 # b/c this one will get caught by rspec's method missing
+        assert_exception consumer.call,
+                         recorded_line_no:   99,
+                         class_name_matcher: /^NameError$/,
+                         message_matcher:    /\bnot_a_local_or_meth\b/,
+                         backtrace_index:    1,
+                         backtrace_line:     backtrace_line,
+                         backtrace_filename: __FILE__
+      end
+
+      context 'when the exception is a SystemExit' do
+        it 'sets the exit status to the one provided' do
+          record_exception { exit 22 }
+          expect(producer.exitstatus).to eq 22
+        end
+
+        it 'sets the exit status to 0 or 1 if exited with true or false' do
+          expect(producer.exitstatus).to eq 0
+          record_exception { exit true }
+          expect(producer.exitstatus).to eq 0
+          record_exception { exit false }
+          expect(producer.exitstatus).to eq 1
+        end
+
+        it 'sets the exit status to 1 if the exception is not a SystemExit' do
+          expect(producer.exitstatus).to eq 0
+          record_exception { raise }
+          expect(producer.exitstatus).to eq 1
+        end
+      end
+
+      context 'recorded line number | line num is provided | it knows the file | exception comes from within file' do
+        let(:exception) { begin; raise "zomg"; rescue; $!; end }
+        let(:linenum)   { __LINE__ - 1 }
+        it "provided one       | true                 | true              | true" do
+          producer.filename = __FILE__
+          producer.record_exception 12, exception
+          assert_exception consumer.call, recorded_line_no: 12
+        end
+        it "provided one       | true                 | true              | false" do
+          exception.backtrace.replace ['otherfile.rb']
+          producer.record_exception 12, exception
+          producer.filename = __FILE__
+          assert_exception consumer.call, recorded_line_no: 12
+        end
+        it "provided one       | true                 | false             | true" do
+          producer.filename = nil
+          producer.record_exception 12, exception
+          assert_exception consumer.call, recorded_line_no: 12
+        end
+        it "provided one       | true                 | false             | false" do
+          exception.backtrace.replace ['otherfile.rb']
+          producer.filename = nil
+          producer.record_exception 12, exception
+          assert_exception consumer.call, recorded_line_no: 12
+        end
+        it "from backtrace     | false                | true              | true" do
+          producer.filename = __FILE__
+          producer.record_exception nil, exception
+          assert_exception consumer.call, recorded_line_no: linenum
+        end
+        it "-1                 | false                | true              | false" do
+          exception.backtrace.replace ['otherfile.rb']
+          producer.filename = __FILE__
+          producer.record_exception nil, exception
+          assert_exception consumer.call, recorded_line_no: -1
+        end
+        it "-1                 | false                | false             | true" do
+          producer.filename = nil
+          producer.record_exception nil, exception
+          assert_exception consumer.call, recorded_line_no: -1
+        end
+        it "-1                 | false                | false             | false" do
+          exception.backtrace.replace ['otherfile.rb']
+          producer.filename = nil
+          producer.record_exception nil, exception
+          assert_exception consumer.call, recorded_line_no: -1
         end
-        backtrace_frame = 1 # b/c this one will get caught by method missing
-        assert_exception consumer.call, 99, 'NameError', /\bnot_a_local_or_meth\b/, 1, __LINE__-5
       end
     end
 
@@ -309,23 +390,7 @@ module SeeingIsBelieving::EventStream
     describe 'finish!' do
       def final_event(producer, consumer, event_class)
         producer.finish!
-        consumer.call(5).find { |e| e.class == event_class }
-      end
-
-      describe 'bug_in_sib' do
-        it 'truthy values are transated to true' do
-          producer.bug_in_sib = 'a value'
-          expect(final_event(producer, consumer, Events::BugInSiB).value).to equal true
-        end
-
-        it 'falsy values are translated to false' do
-          producer.bug_in_sib = nil
-          expect(final_event(producer, consumer, Events::BugInSiB).value).to equal false
-        end
-
-        it 'is false by default, and is always emitted' do
-          expect(final_event(producer, consumer, Events::BugInSiB).value).to equal false
-        end
+        consumer.call(4).find { |e| e.class == event_class }
       end
 
       describe 'max_line_captures' do
@@ -356,15 +421,15 @@ module SeeingIsBelieving::EventStream
 
         it 'updates its value if it sees a result from a line larger than its value' do
           producer.num_lines = 2
-          producer.record_result :sometype, 5, :someval
-          expect(final_event(producer, consumer, Events::NumLines).value).to eq 5
+          producer.record_result :sometype, 100, :someval
+          expect(final_event(producer, consumer, Events::NumLines).value).to eq 100
         end
 
         it 'updates its value if it sees an exception from a line larger than its value' do
           producer.num_lines = 2
           begin; raise; rescue; e = $!; end
-          producer.record_exception 5, e
-          expect(final_event(producer, consumer, Events::NumLines).value).to eq 5
+          producer.record_exception 100, e
+          expect(final_event(producer, consumer, Events::NumLines).value).to eq 100
         end
       end
 

data/spec/seeing_is_believing_spec.rb

@@ -46,9 +46,10 @@ RSpec.describe SeeingIsBelieving do
   end
 
   it 'allows uers to pass in their own inspection recorder' do
-    wrapper = lambda { |program, num_captures|
+    wrapper = lambda { |program, filename, num_captures|
       SeeingIsBelieving::InspectExpressions.call \
         program,
+        filename,
         num_captures,
         after_each: -> line_number { ").tap { $SiB.record_result(:inspect, #{line_number}, 'zomg') }" }
     }
@@ -144,6 +145,30 @@ RSpec.describe SeeingIsBelieving do
     expect(result.exception.backtrace).to be_a_kind_of Array
   end
 
+  context 'exceptions in exit blocks', t:true do
+    # I'm punting on this because there is just no good way to stop that from happening without changing actual behaviour
+    # see https://github.com/JoshCheek/seeing_is_believing/issues/24
+    it 'does not include information about the_matrix in the exception backtraces' do
+      result1 = invoke("raise Exception, 'something'")
+      result2 = invoke("at_exit { raise Exception, 'something' }")
+      result1.exception.backtrace.each { |line| expect(line).to_not match /the_matrix/ }
+      result2.exception.backtrace.each { |line| expect(line).to_not match /the_matrix/ }
+    end
+
+    it 'can print in at_exit hooks' do
+      result = invoke("at_exit { $stderr.print 'err output'; $stdout.print 'out output' }")
+      expect(result.stderr).to eq 'err output'
+      expect(result.stdout).to eq 'out output'
+    end
+
+    it 'can see previous hooks exceptions' do
+      result = invoke("at_exit { puts $!.message.reverse}; at_exit { raise 'reverse this' }")
+      expect(result.stdout).to eq "siht esrever\n"
+    end
+  end
+
+
+
   it 'does not fuck up __LINE__ macro' do
     expect(values_for( '__LINE__
                         __LINE__
@@ -444,7 +469,7 @@ RSpec.describe SeeingIsBelieving do
     it 'prints the pre-evaluated program' do
       call
       expect(stream.string).to include "TRANSLATED PROGRAM:"
-      expect(stream.string).to include "\nbegin;" # there is more, but we're just interested in showing that it wound up in the stream
+      expect(stream.string).to include "$SiB.num_lines" # there is more, but we're just interested in showing that it wound up in the stream
     end
 
     it 'prints the result' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 3.0.0.beta.2
+  version: 3.0.0.beta.3
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-27 00:00:00.000000000 Z
+date: 2014-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eval_in
@@ -267,7 +267,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: seeing_is_believing
-rubygems_version: 2.0.14
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Records results of every line of code in your file
@@ -293,3 +293,4 @@ test_files:
 - spec/seeing_is_believing_spec.rb
 - spec/spec_helper.rb
 - spec/wrap_expressions_spec.rb
+has_rdoc: