seeing_is_believing 3.1.1 → 3.2.0

data/spec/hard_core_ensure_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'ichannel'
 require 'seeing_is_believing/hard_core_ensure'
 
 RSpec.describe SeeingIsBelieving::HardCoreEnsure do
@@ -41,54 +40,81 @@ RSpec.describe SeeingIsBelieving::HardCoreEnsure do
     expect(ensure_invoked).to eq true
   end
 
-  it 'invokes the code even if an interrupt is sent and there is a default handler' do
-    test = lambda do
-      channel = IChannel.unix
-      pid = fork do
-        old_handler = trap('INT') { channel.put "old handler invoked" }
-        call code: -> { sleep 0.1 }, ensure: -> { channel.put "ensure invoked" }
-        trap 'INT', old_handler
-      end
-      sleep 0.05
-      Process.kill 'INT', pid
-      Process.wait pid
-      expect(channel.get).to eq "ensure invoked"
-      expect(channel.get).to eq "old handler invoked"
-      expect(channel).to_not be_readable
-    end
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      pending "Skipping this test on jruby b/c the JVM doesn't have a fork"
-      raise
-    else
-      test.call
-    end
+  def ruby(program)
+    child = ChildProcess.build RbConfig.ruby,
+                               '-I', File.expand_path('../lib', __dir__),
+                               '-r', 'seeing_is_believing/hard_core_ensure',
+                               '-e', program
+    child.duplex = true
+    outread, outwrite = IO.pipe
+    errread, errwrite = IO.pipe
+    child.io.stdout = outwrite
+    child.io.stderr = errwrite
+    child.start
+    outwrite.close
+    errwrite.close
+    yield child, outread
+  ensure
+    errread && !errread.closed? && expect(errread.read).to(be_empty)
+    outread.close unless outread.closed?
   end
 
-  it 'invokes the code even if an interrupt is sent and interrupts are set to ignore' do
-    test = lambda do
-      channel = IChannel.unix
-      pid = fork do
-        old_handler = trap 'INT', 'IGNORE'
-        result = call code: -> { sleep 0.1; 'code result' }, ensure: -> { channel.put "ensure invoked" }
-        channel.put result
-        trap 'INT', old_handler
+
+  # for fuck sake, I can't get Windows to let me trap the interrupt
+  it 'invokes the code even if an interrupt is sent and there is a default handler', windows: false do
+    program = <<-RUBY
+      trap("INT") do
+        puts %(CUSTOM-HANDLER)
+        exit
       end
-      sleep 0.05
-      Process.kill 'INT', pid
-      Process.wait pid
-      expect(channel.get).to eq "ensure invoked"
-      expect(channel.get).to eq 'code result'
-      expect(channel).to_not be_readable
+      SeeingIsBelieving::HardCoreEnsure.new(
+        code:   -> { puts %(CODE); $stdout.flush; sleep },
+        ensure: -> { puts %(ENSURE) },
+      ).call
+    RUBY
+    ruby program do |ps, psout|
+      expect(psout.gets.chomp).to eq "CODE"
+      # is_alive = ChildProcess::Windows::Lib.alive?(ps.pid)
+      Process.kill 'INT', ps.pid
+
+      expect(psout.gets.chomp).to eq "ENSURE"
+      expect(psout.gets.chomp).to eq "CUSTOM-HANDLER"
     end
+  end
+
+  it 'invokes the code even if an interrupt is sent and interrupts are set to ignore', windows: false do
+    # empty string isn't documented, but it causes ignore too
+    # https://github.com/ruby/ruby/blob/256d8c9ecffbcd8f4fe7562b866fcd55f1d445e7/signal.c#L1128-L1129
+    ignore_handlers = ['IGNORE', 'SIG_IGN', '']
+
+    ignore_handlers.each do |handler|
+      program = <<-RUBY
+        trap %(INT), #{handler.inspect}
+        SeeingIsBelieving::HardCoreEnsure.new(
+          code:   -> {
+            puts %(CODE1)
+            $stdout.flush
+            gets
+            puts %(CODE2)
+          },
+          ensure: -> { puts %(ENSURE) },
+        ).call
+      RUBY
+      ruby program do |ps, psout|
+        expect(psout.gets).to eq "CODE1\n" # we're in the code block
+        Process.kill 'INT', ps.pid         # should be ignored
 
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      pending "Skipping this test on jruby b/c the JVM doesn't have a fork"
-      raise # new rspec will keep executing code and fail b/c nothing is raised
-    elsif (!defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby') && (RUBY_VERSION == '2.1.1' || RUBY_VERSION == '2.1.2')
-      pending 'This test can\'t run on MRI (2.1.1 or 2.1.2) b/c of bug, see https://github.com/JoshCheek/seeing_is_believing/issues/26'
-      raise # new rspec will keep executing code and fail b/c nothing is raised
-    else
-      test.call # works on Rubinius
+        # note that if we don't check this, the pipe on the next line may beat the signal
+        # to the process leading to nondeterministic printing
+        expect(ps).to be_alive
+
+        ps.io.stdin.puts "wake up!"
+        ps.wait
+        expect(ps.exit_code).to eq 0
+        expect(psout.gets).to eq "CODE2\n"
+        expect(psout.gets).to eq "ENSURE\n"
+        expect(psout.gets).to eq nil
+      end
     end
   end
 end

data/spec/seeing_is_believing_spec.rb

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 
-
 require 'spec_helper'
 require 'stringio'
 require 'seeing_is_believing'
-require 'ichannel'
+require 'childprocess'
+require 'json'
 
 RSpec.describe SeeingIsBelieving do
   def method_result(name)
@@ -30,12 +30,10 @@ RSpec.describe SeeingIsBelieving do
     invoke(input, options).to_a
   end
 
-  root_path       = File.expand_path("../..", __FILE__)
-  proving_grounds = File.expand_path('proving_grounds', root_path)
-  before(:all) { Dir.mkdir proving_grounds unless Dir.exist? proving_grounds }
-  around { |spec| Dir.chdir proving_grounds, &spec }
-
-  let(:proving_grounds_dir) { File.expand_path '../../proving_grounds', __FILE__ }
+  root_path            = File.realpath("..", __dir__)
+  proving_grounds_path = File.realdirpath('proving_grounds', root_path)
+  before(:all) { Dir.mkdir proving_grounds_path unless Dir.exist? proving_grounds_path }
+  around { |spec| Dir.chdir proving_grounds_path, &spec }
 
   it 'takes a string and returns a result of the line numbers (counting from 1) and each inspected result from that line' do
     input  = "10+10\n'2'+'2'"
@@ -48,8 +46,8 @@ RSpec.describe SeeingIsBelieving do
   end
 
   it 'only invokes inspect once' do
-    input = "class Fixnum; def inspect; 'NUM'\nend\nend\n1"
-    expect(invoke(input)[1]).to eq ['"NUM"']
+    input = "class Array; def inspect; 'INSPECTED'\nend\nend\n[]"
+    expect(invoke(input)[1]).to eq ['"INSPECTED"']
   end
 
   it 'makes the SiB version info available' do
@@ -167,6 +165,28 @@ RSpec.describe SeeingIsBelieving do
     expect(result.exception.backtrace).to be_a_kind_of Array
   end
 
+  it 'allows multiple exceptions (eg because of a fork)', needs_fork: true do
+    errors = [
+      { class_name: 'TypeError',     message: 'a', line_number: 2},
+      { class_name: 'ArgumentError', message: 'b', line_number: 4},
+    ]
+
+    result = invoke(<<-RUBY)
+      if fork
+        raise #{errors[0].fetch(:class_name)}, #{errors[0].fetch(:message).inspect}
+      else
+        raise #{errors[1].fetch(:class_name)}, #{errors[1].fetch(:message).inspect}
+      end
+    RUBY
+
+    expect(result.exceptions.length).to eq errors.length
+    result.exceptions.sort_by(&:line_number).zip(errors).each do |actual, expected|
+      expected.each do |key, value|
+        expect(actual[key]).to eq value
+      end
+    end
+  end
+
   context 'exceptions in exit blocks' 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
@@ -301,21 +321,21 @@ RSpec.describe SeeingIsBelieving do
   end
 
   it 'defaults the filename to temp_dir/program.rb' do
-    result = invoke('print File.expand_path __FILE__')
+    result = invoke('print File.realpath __FILE__')
     expect(File.basename(result.stdout)).to eq 'program.rb'
   end
 
   it 'can be told to run as a given file (in a given dir/with a given filename)' do
-    filename = File.join proving_grounds_dir, 'mah_file.rb'
+    filename = File.join proving_grounds_path, 'mah_file.rb'
     FileUtils.rm_f filename
-    result   = invoke 'print File.expand_path __FILE__', filename: filename
+    result   = invoke 'print File.realpath __FILE__', filename: filename
     expect(result.stdout).to eq filename
   end
 
   specify 'cwd of the file is the cwd of the evaluating program' do
-    filename = File.join proving_grounds_dir, 'mah_file.rb'
+    filename = File.join proving_grounds_path, 'mah_file.rb'
     FileUtils.rm_f filename
-    expect(invoke('print File.expand_path(Dir.pwd)', filename: filename).stdout).to eq Dir.pwd
+    expect(invoke('print File.realdirpath(Dir.pwd)', filename: filename).stdout).to eq Dir.pwd
   end
 
   it 'does not capture output from __END__ onward' do
@@ -511,31 +531,87 @@ RSpec.describe SeeingIsBelieving do
   end
 
   it 'respects timeout, even when children do semi-ridiculous things, it cleans up children rather than orphaning them' do
-    # https://github.com/JoshCheek/seeing_is_believing/issues/53
-    result = invoke <<-RUBY, timeout_seconds: 0.1
-      read, write = IO.pipe
-      fork               # child makes a grandchild
-      puts Process.pid   # print current pid
-      read.read          # block child and grandchild
+    pre    = Time.now
+    result = invoke <<-CHILD, timeout_seconds: 0.5
+      read, _ = IO.pipe
+
+      # bock grandchild
+      pid = spawn 'ruby', '-e', '$stdin.read', in: read
+
+      puts Process.pid    # print child pid
+      puts pid            # print grandchild id
+      read.read           # block child
+    CHILD
+    post   = Time.now
+    expect(result.timeout?).to eq true
+    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
+
+
+  # see https://github.com/JoshCheek/seeing_is_believing/pull/92
+  # and https://github.com/JoshCheek/seeing_is_believing/pull/94
+  # I can't figure out how to get it working on Windows. Not sure if
+  # this is because there's a problem with it, or because Windows
+  # handles traps differently, or because the feedback cycle is too painful.
+  # (I have to start a VM, clone the shit, setup a mediocre vim,
+  # use powershell which I don't know, just all the little things
+  # are off so someting as simple as dropping a pry into the test
+  # to figure out WTF is going on, it becomes prohibitively difficult)
+  it 'kills the child and all of its children when the main SiB process gets killed, even if they\'re nonsensing it up', windows: false do
+    # start SiB, it will make a child, use --stream so we can
+    # access individual events as they are emitted (to get the pids)
+    bin_path = File.realpath '../bin/seeing_is_believing', __dir__
+    sib = ChildProcess.build bin_path, '--stream', '-e', <<-RUBY
+      # the child makes a grandchild that ignores interrupts and sleeps
+      spawn %(ruby), %(-e), %(trap %(INT), %(IGNORE); sleep)
+
+      # the child ignores interrupts and sleeps
+      trap %(INT), %(IGNORE)
+      Process.pid
+      sleep
     RUBY
-    result.stdout.lines.map(&:to_i).each do |pid|
-      expect { Process.kill 0, pid }.to raise_error(Errno::ESRCH)
+
+    # Hook up the io and start the child process
+    read, write   = IO.pipe
+    sib.io.stdout = write
+    sib.io.stderr = write
+    sib.duplex    = true # otherwise it takes the real process's stdin, which will mess w/ pry
+    sib.start
+    write.close
+
+    # Get the child and grandchild ids. If we read too far, we lock up the test
+    pids = []
+    until pids.length == 2
+      event, data = JSON.parse read.gets
+      next unless event == 'line_result'
+      next unless data.fetch('inspected') =~ /\A\d+\z/
+      pids << data.fetch('inspected').to_i
     end
-  end
 
-  it 'does not kill parent processes' do
-    channel = IChannel.unix
-    fork do
-      # it's basically undocumented, but I think 0 makes it choose a new group id
-      # this is so that we don't kill the test if it gets messed up
-      Process.setpgid(Process.pid, 0)
-      channel.put invoke("1"                          ).timeout_seconds
-      channel.put invoke("sleep", timeout_seconds: 0.1).timeout_seconds
+    # Interrupt SiB, it interrupts child and grandchild
+    expect(sib).to be_alive
+    Process.kill 'INT', sib.pid
+
+    # wait for it to finish cleaning up so we don't check pids before it gets around to killing them
+    sib.wait
+
+    # Apparently we can check if processes exist by sending them signal 0
+    # http://stackoverflow.com/questions/9152979/check-if-process-exists-given-its-pid
+    # ESRCH = "no such process", what we expect if SiB cleaned them up
+    # if they do exist, they will return `1` (in my experiments)
+    pids.each do |pid|
+      expect { Process.kill 0, pid }.to raise_error Errno::ESRCH
     end
-    expect(channel.get).to eq nil # child exited normally
-    expect(channel.get).to eq 0.1 # child timed out
   end
 
+
   context 'when given a debugger' do
     let(:stream)   { StringIO.new }
     let(:debugger) { SeeingIsBelieving::Debugger.new stream: stream }
@@ -558,7 +634,7 @@ RSpec.describe SeeingIsBelieving do
     end
   end
 
-  describe 'fork' do
+  describe 'fork', needs_fork: true do
     it 'records results from both parent and child, without double reporting items that may have been left in the queue at the time of forking' do
       n = 100
       result = invoke <<-RUBY
@@ -594,7 +670,7 @@ RSpec.describe SeeingIsBelieving do
       expect(ones).to  eq ("1"*(n-1))
     end
 
-    it 'works for Kernel#fork, Kernel.fork, Process.fork' do
+    it 'works for Kernel#fork, Kernel.fork, Process.fork', needs_fork: true do
       result = invoke <<-RUBY
         $$
         if fork
@@ -701,18 +777,36 @@ RSpec.describe SeeingIsBelieving do
     end
 
     specify 'when Fixnum does not have <, <<, next, ==, inspect, to_s' do
-      result = invoke('class Fixnum
+      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
+    end
+
+    specify 'when Integer does not have <, <<, next, ==, inspect, to_s' do
+      result = invoke('class Integer
                          undef <
-                         undef <<
+                         undef << if instance_methods.include? :<<   # ruby 2.4+
                          undef ==
-                         def next
-                           "redefining instead of undefing b/c it comes from Integer"
-                         end
+                         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
 
@@ -792,7 +886,7 @@ RSpec.describe SeeingIsBelieving do
       expect(result.exception.class_name).to eq 'RuntimeError'
     end
 
-    specify 'when Thread does not have .new, .current, #join, #abort_on_exception' do
+    specify 'when Thread does not have .new, .current, #join, #abort_on_exception', needs_fork: true do
       expect(invoke('class << Thread
                        undef new
                        undef current if "2.0.0" != RUBY_VERSION && "1.9.3" != RUBY_VERSION

data/spec/spec_helper.rb

@@ -31,4 +31,12 @@ RSpec.configure do |c|
   c.disable_monkey_patching!
   c.include SibSpecHelpers
   c.filter_run_excluding :not_implemented
+
+  if RSpec::Support::OS.windows? || RSpec::Support::Ruby.jruby?
+    c.before(needs_fork: true) { skip 'Fork is not available on this system' }
+  end
+
+  if RSpec::Support::OS.windows?
+    c.before(windows: false) { skip "This either doesn't work or I can't figure out how to test it on Windows" }
+  end
 end

data/spec/wrap_expressions_spec.rb

@@ -205,6 +205,7 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     end
 
     it 'wraps macros' do
+      expect(wrap("__dir__")).to eq "<__dir__>"
       expect(wrap("__FILE__")).to eq "<__FILE__>"
       expect(wrap("__LINE__")).to eq "<__LINE__>"
       expect(wrap("__ENCODING__")).to eq "<__ENCODING__>"
@@ -475,6 +476,20 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("case\nwhen 2, 3 then\n4\n5\nend")).to eq "<case\nwhen 2, 3 then\n<4>\n<5>\nend>"
     end
 
+    it 'does not wrap flip flops in if-statement conditionals' do
+      # these match
+      expect(wrap("if (a==1)..(zomg.wtf?)\n  1\nend")).to eq "<if (a==1)..(zomg.wtf?)\n  <1>\nend>"
+      expect(wrap("if (a==1)...(zomg.wtf?)\n  1\nend")).to eq "<if (a==1)...(zomg.wtf?)\n  <1>\nend>"
+
+      # these match $_
+      expect(wrap("if /a/../b/\n  1\nend")).to eq "<if /a/../b/\n  <1>\nend>"
+      expect(wrap("if /a/.../b/\n  1\nend")).to eq "<if /a/.../b/\n  <1>\nend>"
+
+      # these are match $.
+      expect(wrap("if 1..2\n  1\nend")).to eq "<if 1..2\n  <1>\nend>"
+      expect(wrap("if 1...2\n  1\nend")).to eq "<if 1...2\n  <1>\nend>"
+    end
+
     it 'does not wrap if the last value in any portion is a void value expression' do
       expect(wrap("def a\nif true\nreturn 1\nend\nend")).to eq "<def a\nif <true>\nreturn <1>\nend\nend>"
       expect(wrap("def a\nif true\n1\nelse\nreturn 2\nend\nend")).to eq "<def a\nif <true>\n<1>\nelse\nreturn <2>\nend\nend>"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-19 00:00:00.000000000 Z
+date: 2017-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -30,6 +30,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.9
 - !ruby/object:Gem::Dependency
   name: haiti
   requirement: !ruby/object:Gem::Requirement
@@ -107,19 +121,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.4'
 - !ruby/object:Gem::Dependency
-  name: ichannel
+  name: ripper-tags
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: '0.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: '0.3'
 description: 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"
@@ -136,6 +150,7 @@ files:
 - Gemfile
 - Rakefile
 - Readme.md
+- appveyor.yml
 - bin/seeing_is_believing
 - docs/example.gif
 - docs/frog-brown.png
@@ -264,7 +279,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: seeing_is_believing
-rubygems_version: 2.0.14.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Records results of every line of code in your file