seeing_is_believing 3.6.1 → 4.0.0

data/lib/seeing_is_believing/the_matrix.rb

@@ -48,23 +48,32 @@ Kernel.module_eval do
   private
 
   define_method :warn do |*args, &block|
-    $stderr.puts *args
+    $stderr.puts(*args)
   end
 
+  alias :exec :exec # disable warning
   define_method :exec do |*args, &block|
     $SiB.record_exec(args)
     finish.call
     real_exec.call(*args, &block)
   end
 
+  alias :exit! :exit! # disable warning
   define_method :exit! do |status=false|
     finish.call
     real_exit_bang.call(status)
   end
 
+  alias :fork :fork
   define_method :fork, &fork_defn
 end
 
+module Process
+  class << self
+    alias :fork :fork
+  end
+end
+
 Kernel.define_singleton_method  :fork, &fork_defn
 Process.define_singleton_method :fork, &fork_defn
 
@@ -74,10 +83,14 @@ symbol_to_s         = Symbol.instance_method(:to_s)
 exception_message   = Exception.instance_method(:message)
 exception_backtrace = Exception.instance_method(:backtrace)
 
+# Guarding against hostile users (e.g. me) that do ridiculous things like blowing away these constants
+exception_class = Exception
+symbol_class    = Symbol
+
 at_exit do
-  Exception.class_eval { define_method :message,   exception_message }
-  Exception.class_eval { define_method :backtrace, exception_backtrace }
-  Symbol.class_eval    { define_method :to_s,      symbol_to_s }
+  exception_class.class_eval { define_method :message,   exception_message }
+  exception_class.class_eval { define_method :backtrace, exception_backtrace }
+  symbol_class.class_eval    { define_method :to_s,      symbol_to_s }
   exitstatus = ($! ? $SiB.record_exception(nil, $!) : 0)
   finish.call
   real_exit_bang.call(exitstatus) # clears exceptions so they don't print to stderr and change the processes actual exit status (we recorded what it should be)

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.6.1'
+  VERSION = '4.0.0'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -25,7 +25,7 @@ class SeeingIsBelieving
 
         wrappings = wrappings().sort_by(&:first)
 
-        wrappings.each do |line_num, (range, last_col, meta)|
+        wrappings.each do |line_num, (range, _last_col, meta)|
           case meta
           when :total_fucking_failure
             rewriter.replace range,  '.....TOTAL FUCKING FAILURE!.....'
@@ -34,11 +34,11 @@ class SeeingIsBelieving
           end
         end
 
-        wrappings.each do |line_num, (range, last_col, meta)|
+        wrappings.each do |line_num, (range, _last_col, _meta)|
           rewriter.insert_before range, before_each.call(line_num)
         end
 
-        wrappings.each do |line_num, (range, last_col, meta)|
+        wrappings.each do |line_num, (range, _last_col, _meta)|
           rewriter.insert_after range, after_each.call(line_num)
         end
 
@@ -53,8 +53,13 @@ class SeeingIsBelieving
     attr_accessor :before_all, :after_all, :before_each, :after_each
     attr_accessor :code, :wrappings
 
-    def buffer()          code.buffer            end
-    def rewriter()        code.rewriter          end
+    def buffer
+      code.buffer
+    end
+
+    def rewriter
+      code.rewriter
+    end
 
     def root_range
       code.root.location.expression
@@ -107,7 +112,10 @@ class SeeingIsBelieving
       when :defs, :module
         add_to_wrappings ast
         add_children ast, true
-      when :rescue, :ensure, :return, :break, :next, :splat, :kwsplat
+      when :ensure, :return, :break, :next, :splat, :kwsplat
+        add_children ast
+      when :rescue
+        add_to_wrappings ast if inline_rescue? ast
         add_children ast
       when :class
         name,      * = ast.children
@@ -135,8 +143,8 @@ class SeeingIsBelieving
         add_to_wrappings ast
         the_begin = ast.location.begin
         if !the_begin
-          # uhhhh, idk, nothing seems to hit this branch (at least in its spec)
-          # maybe this is 'a = 1,2,3'? (I'd try it out, but have to call the folks)
+          # a = 1,2,3
+          add_children ast
         elsif the_begin.source !~ /\A%/
           # normal array
           add_children ast
@@ -247,5 +255,11 @@ class SeeingIsBelieving
         add_children ast
       end
     end
+
+    def inline_rescue?(ast)
+      primary_code, rescue_body, _else_body = ast.children
+      return false unless primary_code
+      primary_code.loc.expression.last_line == rescue_body.loc.expression.first_line
+    end
   end
 end

data/lib/seeing_is_believing/wrap_expressions_with_inspect.rb

@@ -5,6 +5,9 @@ class SeeingIsBelieving
       # NOTE: if it received the AST, it could figure out if it needs
       # to always wrap the expression in parentheses
       WrapExpressions.call program,
+        before_all: -> {
+          "BEGIN { $SiB.file_loaded };"
+        },
         before_each: -> line_number {
           "$SiB.record_result(:inspect, #{line_number}, ("
         },

data/seeing_is_believing.gemspec

@@ -12,19 +12,18 @@ Gem::Specification.new do |s|
   s.description = %q{Records the results of every line of code in your file (intended to be like xmpfilter), inspired by Bret Victor's JavaScript example in his talk "Inventing on Principle"}
   s.license     = "WTFPL"
 
-  s.rubyforge_project = "seeing_is_believing"
-
   s.files         = `git ls-files`.split("\n") - ['docs/seeing is believing.psd'] # remove psd b/c it boosts the gem size from 50kb to 20mb O.o
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency             "parser",      "~> 2.5.0"
-  s.add_dependency             "childprocess","~> 0.8.0"
+  s.add_dependency             "parser",      "~> 2.7.0"
+  s.add_dependency             "childprocess","~> 3.0.0"
+  s.add_dependency             "ffi",         "~> 1.11.1"
 
   s.add_development_dependency "pry"
   s.add_development_dependency "haiti",       ">= 0.1", "< 0.3"
-  s.add_development_dependency "rake",        "~> 12.2.0"
+  s.add_development_dependency "rake",        "~> 13.0.0"
   s.add_development_dependency "mrspec",      "~>  0.3.1"
   s.add_development_dependency "rspec",       "~>  3.6.0"
   s.add_development_dependency "cucumber",    "~>  2.4"

data/spec/binary/config_spec.rb

@@ -257,8 +257,8 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse([]).lib_options.require_files).to eq [matrix_file]
       end
 
-      it 'appends pp and our customizations for xmpfilter style' do
-        expect(parse(['-x']).lib_options.require_files).to eq [matrix_file, 'pp', 'seeing_is_believing/customize_pp']
+      it 'appends pp for xmpfilter style' do
+        expect(parse(['-x']).lib_options.require_files).to eq [matrix_file, 'pp']
       end
 
       specify '-r and --require set an error if not provided with a filename' do

data/spec/evaluate_by_moving_files_spec.rb

@@ -23,32 +23,32 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
   def invoke(program, options={})
     result = SeeingIsBelieving::Result.new
     options[:event_handler] ||= SeeingIsBelieving::EventStream::Handlers::UpdateResult.new(result)
-    evaluator = described_class.new(program, filename, options)
-    FileUtils.rm_f evaluator.backup_filename
+    evaluator = described_class.new(filename, program, program, options)
+    FileUtils.rm_f evaluator.backup_path
     evaluator.call
     result
   end
 
-  it 'evaluates the code when the file DNE' do
+  it 'evaluates the code as the given file' do
+    expect(invoke('print __FILE__').stdout).to eq filename
+  end
+
+  it 'evaluates the code when the given file DNE' do
     FileUtils.rm_f filename
     expect(invoke('print 1').stdout).to eq '1'
   end
 
-  it 'evaluates the code when the file Exists' do
+  it 'evaluates the code when the given file Exists' do
     FileUtils.touch filename
     expect(invoke('print 1').stdout).to eq '1'
   end
 
   it 'raises an error when the temp file already exists' do
-    evaluator = described_class.new('', filename, null_options)
-    FileUtils.touch evaluator.backup_filename
+    evaluator = described_class.new(filename, '', '', null_options)
+    FileUtils.touch evaluator.backup_path
     expect { evaluator.call }.to raise_error SeeingIsBelieving::TempFileAlreadyExists
   end
 
-  it 'evaluates the code as the given file' do
-    expect(invoke('print __FILE__').stdout).to eq filename
-  end
-
   it 'does not change the original file' do
     File.open(filename, 'w') { |f| f.write "ORIGINAL" }
     invoke '1 + 1'
@@ -56,29 +56,29 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'uses HardCoreEnsure to move the file back' do
-    evaluator = described_class.new 'PROGRAM', filename, null_options
+    evaluator = described_class.new filename, 'PROGRAM', 'PROGRAM', null_options
     File.open(filename, 'w') { |f| f.write 'ORIGINAL' }
-    FileUtils.rm_rf evaluator.backup_filename
+    FileUtils.rm_rf evaluator.backup_path
     expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
-      expect(File.exist? evaluator.backup_filename).to eq false
+      expect(File.exist? evaluator.backup_path).to eq false
       expect(File.read filename).to eq 'ORIGINAL'
 
       # after code
       options[:code].call rescue nil
-      expect(File.read evaluator.backup_filename).to eq 'ORIGINAL'
+      expect(File.read evaluator.backup_path).to eq 'ORIGINAL'
       expect(File.read filename).to eq 'PROGRAM'
 
       # after ensure
       options[:ensure].call
       expect(File.read filename).to eq 'ORIGINAL'
-      expect(File.exist? evaluator.backup_filename).to eq false
+      expect(File.exist? evaluator.backup_path).to eq false
     end
     evaluator.call
   end
 
   it 'uses HardCoreEnsure to delete the file if it wrote it where one did not previously exist' do
-    evaluator = described_class.new 'PROGRAM', filename, null_options
+    evaluator = described_class.new filename, 'PROGRAM', 'PROGRAM', null_options
     FileUtils.rm_rf filename
     expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
@@ -149,7 +149,7 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
 
   it 'must provide an event handler, which receives the process\'s events' do
     # raises error
-    expect { described_class.new("", filename, {}) }
+    expect { described_class.new(filename, "", "", {}) }
       .to raise_error ArgumentError, /event_handler/
 
     # sees all the events
@@ -164,6 +164,7 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     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
+    $stdout.flush
     sleep                                   # child sleeps
     RUBY
     post   = Time.now

data/spec/event_stream_spec.rb

@@ -664,6 +664,7 @@ module SeeingIsBelieving::EventStream
           [Events::StderrClosed     , :stderr_closed],
           [Events::EventStreamClosed, :event_stream_closed],
           [Events::Finished         , :finished],
+          [Events::FileLoaded       , :file_loaded],
         ]
         pairs.each { |klass, name| expect(klass.event_name).to eq name }
 

data/spec/seeing_is_believing_spec.rb

@@ -251,8 +251,8 @@ RSpec.describe SeeingIsBelieving do
     # Currently we dont' differentiate between inline and multiline if statements,
     # also, we can't wrap the whole statement since it's void value, which means we'd have to introduce
     # the idea of multiple wrappings for the same line, which I just don't care enough about to consider
-    expect(values_for("def meth \n return 1 if true  \n end \n meth")).to eq [[], ['1'], [], ['1']]   # records true instead of 1
-    expect(values_for("def meth \n return 1 if false \n end \n meth")).to eq [[], ['nil'], [], ['nil']] # records false instead of nil
+    expect(values_for("def meth \n return 1 if true  \n end \n meth")).to eq [[], ['1'], [':meth'], ['1']]   # records true instead of 1
+    expect(values_for("def meth \n return 1 if false \n end \n meth")).to eq [[], ['nil'], [':meth'], ['nil']] # records false instead of nil
   end
 
   it 'does not try to record the keyword next' do
@@ -557,7 +557,7 @@ RSpec.describe SeeingIsBelieving do
   it 'sees refined inspect (#128)' do
     result = invoke <<-RUBY
     module BinMeUp
-      refine Fixnum do
+      refine Integer do
         def inspect
           "%08b" % self
         end
@@ -569,10 +569,6 @@ RSpec.describe SeeingIsBelieving do
     expect(result[9]).to eq ['00000101']
   end
 
-  it 'works when the exception does not have a backtrace (#134)' do
-
-  end
-
   it 'respects timeout, even when children do semi-ridiculous things, it cleans up children rather than orphaning them' do
     pre    = Time.now
     result = invoke <<-CHILD, timeout_seconds: 0.5
@@ -654,6 +650,18 @@ RSpec.describe SeeingIsBelieving do
     end
   end
 
+  # Okay, doesn't totally belong here, b/c there could be another implementation which doesn't overwrite files,
+  # but it requires coordination between the rewritten code and the evaluator, so isn't really an evaluator unit test,
+  # so putting this here.
+  context 'cleaning up files' do
+    it 'replaces the rewritten source with the original source as soon as it sees a result' do
+      program = "sleep 0.01 while File.read(__FILE__).include?('RECORD_RESULT'.downcase); File.read __FILE__\n"
+      result  = invoke program
+      expect(result[1]).to eq [program.inspect]
+      expect(File.exist? result.filename).to eq false
+    end
+  end
+
 
   context 'when given a debugger' do
     let(:stream)   { StringIO.new }
@@ -823,23 +831,19 @@ RSpec.describe SeeingIsBelieving do
                     ').stderr).to eq ''
     end
 
-    specify 'when Fixnum does not have <, <<, next, ==, inspect, to_s' do
-      if defined? Fixnum
-        result = invoke('class Fixnum
-                           undef <
-                           undef <<
-                           undef ==
-                           def next
-                             "redefining instead of undefing b/c it comes from Integer"
-                           end
-                           undef to_s
-                           undef inspect
-                         end
-                         "a"')
-        expect(result.stderr).to eq ''
-        expect(result.exitstatus).to eq 0
-        expect(result.to_a.last).to eq ['"a"']
-      end
+    specify 'when Integer does not have <, <<, next, ==, inspect, to_s' do
+      result = invoke('class Integer
+                         undef <
+                         undef <<
+                         undef ==
+                         undef next
+                         undef to_s
+                         undef inspect
+                       end
+                       "a"')
+      expect(result.stderr).to eq ''
+      expect(result.exitstatus).to eq 0
+      expect(result.to_a.last).to eq ['"a"']
     end
 
     specify 'when Integer does not have <, <<, next, ==, inspect, to_s' do
@@ -1015,5 +1019,76 @@ RSpec.describe SeeingIsBelieving do
                      end
                     ').stderr).to eq ''
     end
+
+    def executes_without_error!(code)
+      result = invoke(code)
+      expect(result.stderr).to eq ''
+      begin
+        expect(result).to_not have_exception, result.exception.pretty_inspect
+      rescue NoMethodError
+        require 'pp'
+        retry
+      end
+      result
+    end
+
+    specify 'when constants are reassigned' do
+      result = executes_without_error!('
+         # producer
+         Hash            = "fake Hash"
+         String          = "fake String"
+         class << String
+           undef ===
+         end
+         Exception       = "fake Exception"
+
+         kernel          = Kernel
+         Kernel          = "fake Kernel"
+         SystemExit      = "fake SystemExit"
+         NoMethodError   = "fake NoMethodError"
+         Marshal         = "fake Marshal"
+         TypeError       = "fake TypeError"
+
+         # only matter when forking
+         Thread          = "fake Thread"
+         IOError         = "fake IOError"
+         Errno::EPIPE    = "fake Errno::EPIPE" # we don\'t actually put it in a situation to hit this
+         Errno           = "fake Errno"
+
+         # the matrix
+         Exception = "Exception"
+         Symbol    = "Symbol"
+
+         # normal inspect
+         1 + 1
+
+         # force it down the sad path
+         obj = Object.new
+         def obj.inspect
+           "pass"
+         end
+         obj
+         puts __LINE__-1 # so we know where to assert
+
+         NotAString = Module.new
+         def obj.inspect
+           NotAString
+         end
+         obj
+
+         def obj.inspect
+           raise "whoops"
+         end
+         obj
+         puts __LINE__-1 # should be replaced with Kernel#inspect
+
+         kernel.exit 0
+      ')
+
+      pass_str, kernel_inspect = result.stdout.lines.map(&:to_i)
+      expect(result[pass_str]).to eq ['pass']
+      expect(result[kernel_inspect].size).to eq 1
+      expect(result[kernel_inspect][0]).to match /^#<Object/
+    end
   end
 end

data/spec/sib_spec_helpers/version.rb

@@ -0,0 +1,17 @@
+module SibSpecHelpers
+  class Version
+    attr_reader :segments
+    include Comparable
+    def initialize(version_string)
+      @segments = version_string.scan(/\d+/).map(&:to_i)
+    end
+    def <=>(other)
+      other = Version.new other unless other.kind_of? Version
+      segments.zip(other.segments).each do |ours, theirs|
+        return  1 if theirs.nil? || theirs < ours
+        return -1 if ours < theirs
+      end
+      segments.length <=> other.segments.length
+    end
+  end
+end