seeing_is_believing 3.0.1 → 3.1.0

data/spec/binary/config_spec.rb

@@ -220,8 +220,8 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(parse([]).lib_options.require_files).to eq [matrix_file]
       end
 
-      it 'appends pp for xmpfilter style' do
-        expect(parse(['-x']).lib_options.require_files).to eq [matrix_file, 'pp']
+      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']
       end
 
       specify '-r and --require set an error if not provided with a filename' do
@@ -563,6 +563,21 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
   end
 
 
+  describe 'align_results?' do
+    it 'defaults to true' do
+      expect(parse([]).annotator_options.interline_align?).to eq true
+    end
+    it 'can be turned on with --interline-align' do
+      expect(parse(['--interline-align'])).to_not have_error '--interline-align'
+      expect(parse(['--interline-align']).annotator_options.interline_align?).to eq true
+    end
+    it 'can be turned off with --no-interline-align' do
+      expect(parse(['--no-interline-align'])).to_not have_error '--no-interline-align'
+      expect(parse(['--no-interline-align']).annotator_options.interline_align?).to eq false
+    end
+  end
+
+
   describe '.finalize' do
     let(:stdin_data) { 'stdin data' }
     let(:stdin)      { object_double $stdin, read: stdin_data }

data/spec/event_stream_spec.rb

@@ -20,6 +20,7 @@ module SeeingIsBelieving::EventStream
       producer.finish!
       consumer.process_exitstatus(0)
       close_streams eventstream_producer, stdout_producer, stderr_producer
+      consumer.join
     end
 
     before do

data/spec/seeing_is_believing_spec.rb

@@ -560,7 +560,7 @@ RSpec.describe SeeingIsBelieving do
 
   describe 'fork' 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 = 10000
+      n = 100
       result = invoke <<-RUBY
         n  = #{n}
         as = '0' * n; 0
@@ -674,16 +674,6 @@ RSpec.describe SeeingIsBelieving do
                      end').stderr).to eq ''
     end
 
-    specify 'when File does not have sync=, <<, flush, puts, close' do
-      expect(invoke('class File
-                       undef sync
-                       undef <<
-                       undef flush
-                       undef puts
-                       undef close
-                     end').stderr).to eq ''
-    end
-
     specify 'when Queue does not have <<, shift, and clear' do
       expect(invoke('class Queue
                        undef <<
@@ -711,14 +701,19 @@ RSpec.describe SeeingIsBelieving do
     end
 
     specify 'when Fixnum does not have <, <<, next, ==, inspect, to_s' do
-      expect(invoke('class Fixnum
-                       undef <
-                       undef <<
-                       undef ==
-                       undef next
-                       undef to_s
-                       undef inspect
-                     end').stderr).to eq ''
+      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.to_a.last).to eq ['"a"']
     end
 
     specify 'when Hash does not have [], []=, fetch' do
@@ -754,15 +749,16 @@ RSpec.describe SeeingIsBelieving do
                      end').stderr).to eq ''
     end
 
-    specify 'when Kernel does not have defined?, kind_of?' do
-      expect(invoke('class Kernel
-                       undef defined?
+    # defined? is a macro, not a method, otherwise I'd test that here
+    specify 'when Kernel does not have kind_of?' do
+      expect(invoke('module Kernel
                        undef kind_of?
-                     end').stderr).to eq ''
+                     end
+                     1').to_a).to eq [[], [], ['nil'], ['1']]
     end
 
     specify 'when Enumerable does not have map' do
-      expect(invoke('class Module
+      expect(invoke('module Enumerable
                        undef map
                      end
                     ').stderr).to eq ''
@@ -780,15 +776,19 @@ RSpec.describe SeeingIsBelieving do
     end
 
     specify 'when Exception does not have message, class (can\'t get backtrace to work)' do
-      result = invoke('class Exception
-                         undef message
-                         # undef backtrace
-                         undef class
+      result = invoke('begin
+                         raise "hello"
+                       ensure
+                         class Exception
+                           undef message
+                           undef backtrace
+                           def class; "totally the wrong thing" end
+                         end
                        end
-                       raise "hello"
                       ')
       expect(result.exception.message).to eq 'hello'
-      # expect(result.exception.backtrace).to eq 'hello'
+      expect(result.exception.backtrace.length).to eq 1
+      expect(result.exception.backtrace[0]).to match /program\.rb:\d/
       expect(result.exception.class_name).to eq 'RuntimeError'
     end
 
@@ -801,6 +801,8 @@ RSpec.describe SeeingIsBelieving do
                        undef join
                        undef abort_on_exception
                      end
+                     fork
+                     1
                     ').stderr).to eq ''
     end
 
@@ -842,31 +844,34 @@ RSpec.describe SeeingIsBelieving do
                     ').stderr).to eq ''
     end
 
-    context 'not clear that there are good ways to deal with these' do
-      before { skip }
+    specify 'when UnboundMethod does not have bind' do
+      expect(invoke('class UnboundMethod
+                       undef bind
+                     end
+                    ').stderr).to eq ''
+    end
 
-      specify 'when UnboundMethod does not have bind' do
-        expect(invoke('class UnboundMethod
-                         undef bind
-                       end
-                      ').stderr).to eq ''
-      end
+    specify 'when Method does not have call' do
+      expect(invoke('class Method
+                       undef call
+                     end
+                    ').stderr).to eq ''
+    end
 
-      specify 'when Method does not have call' do
-        expect(invoke('class Method
-                         undef call
-                       end
-                      ').stderr).to eq ''
-      end
-      specify 'when Proc does not have call, to_proc' do
-        expect(invoke('class Proc
-                         undef call
-                         undef to_proc
-                       end
-                      ').stderr).to eq ''
-      end
+    specify 'when Proc does not have call, to_proc' do
+      expect(invoke('class Proc
+                       undef call
+                       undef to_proc
+                     end
+                    ').stderr).to eq ''
+    end
+
+    # Apparently it doesn't have a to_proc method, they must check to see if it's nil in the code that implements &
+    specify 'when nil does not have to_s' do
+      expect(invoke('class NilClass
+                       undef to_s
+                     end
+                    ').stderr).to eq ''
     end
   end
 end
-
-# all of them together

data/spec/spec_helper.rb

@@ -3,6 +3,28 @@ module SibSpecHelpers
     pending message
     raise message
   end
+
+  def ruby_version
+    Version.new RUBY_VERSION
+  end
+
+
+  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
 
 RSpec.configure do |c|

data/spec/spec_helper_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe SibSpecHelpers::Version do
+  let(:v231) { SibSpecHelpers::Version.new '2.3.1' }
+  example { expect(v231).to eq v231 }
+  example { expect(v231).to eq '2.3.1' }
+  example { expect(v231).to_not be < '2' }
+  example { expect(v231).to     be < '3' }
+  example { expect(v231).to_not be < '2.2' }
+  example { expect(v231).to_not be < '2.3' }
+  example { expect(v231).to     be < '2.4' }
+  example { expect(v231).to_not be < '2.3.0' }
+  example { expect(v231).to_not be < '2.3.1' }
+  example { expect(v231).to     be < '2.3.2' }
+  example { expect(v231).to     be < '2.3.1.0' }
+end

data/spec/wrap_expressions_spec.rb

@@ -637,6 +637,10 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(heredoc_wrap "<<A\n123\nA").to eq "[{<<A}]\n123\nA"
       expect(heredoc_wrap "<<-A\nA").to eq "[{<<-A}]\nA"
       expect(heredoc_wrap "<<-A\n123\nA").to eq "[{<<-A}]\n123\nA"
+      if ruby_version >= '2.3'
+        expect(heredoc_wrap "<<~A\nA").to eq "[{<<~A}]\nA"
+        expect(heredoc_wrap "<<~A\n123\nA").to eq "[{<<~A}]\n123\nA"
+      end
       expect(heredoc_wrap "1\n<<A\nA").to eq "[{1}\n{<<A}]\nA"
       expect(heredoc_wrap "<<A + <<B\n1\nA\n2\nB").to eq "[{<<A + <<B}]\n1\nA\n2\nB"
       expect(heredoc_wrap "<<A\n1\nA\n<<B\n2\nB").to eq "[{<<A}\n1\nA\n{<<B}]\n2\nB"
@@ -667,6 +671,12 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(heredoc_wrap "<<A.whatever(<<B)\nA\nB").to eq "[{<<A.whatever(<<B)}]\nA\nB"
       expect(heredoc_wrap "<<A.size()\nA").to eq "[{<<A.size()}]\nA"
     end
+
+    it 'is not confused by external heredocs (backticks)' do
+      expect(heredoc_wrap "<<`A`\nA").to eq "[{<<`A`}]\nA"
+      expect(heredoc_wrap "<<-`A`\nA").to eq "[{<<-`A`}]\nA"
+      expect(heredoc_wrap "<<~`A`\nA").to eq "[{<<~`A`}]\nA" if ruby_version >= '2.3'
+    end
   end
 
   # raises can be safely ignored, they're just method invocations
@@ -805,6 +815,31 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     end
   end
 
+  describe 'interpolation wraps the whole value and interpolated values' do
+    def self.assert_interpolates(name, code, expected)
+      example(name) { expect(wrap code).to eq expected }
+    end
+
+    assert_interpolates 'backtick syscall',     "`a\#{\n1\n}\nb\n`",    "<`a\#{\n<1>\n}\nb\n`>"
+    assert_interpolates 'slash regex',          "/a\#{\n1\n}\nb\n/",    "</a\#{\n<1>\n}\nb\n/>"
+    assert_interpolates 'double quoted string', "\"a\#{\n1\n}\nb\n\"",  "<\"a\#{\n<1>\n}\nb\n\">"
+    assert_interpolates 'double quoted symbol', ":\"a\#{\n1\n}\nb\n\"", "<:\"a\#{\n<1>\n}\nb\n\">"
+
+    assert_interpolates 'symbol array with interpolation', "%I.a\#{\n1\n}\nb\n.", "<%I.a\#{\n<1>\n}\nb\n.>"
+    assert_interpolates '%x syscall',                      "%x.a\#{\n1\n}\nb\n.", "<%x.a\#{\n<1>\n}\nb\n.>"
+    assert_interpolates '% string',                        "%.a\#{\n1\n}\nb\n.",  "<%.a\#{\n<1>\n}\nb\n.>"
+    assert_interpolates 'string array with interpolation', "%W.a\#{\n1\n}\nb\n.", "<%W.a\#{\n<1>\n}\nb\n.>"
+    assert_interpolates '%r regex',                        "%r.a\#{\n1\n}\nb\n.", "<%r.a\#{\n<1>\n}\nb\n.>"
+    assert_interpolates '%Q string',                       "%Q.a\#{\n1\n}\nb\n.", "<%Q.a\#{\n<1>\n}\nb\n.>"
+
+    assert_interpolates '%s symbol',                          "%s.a\#{\n1\n}\nb\n.", "<%s.a\#{\n1\n}\nb\n.>"
+    assert_interpolates 'single quoted string',               "'a\#{\n1\n}\nb\n'",   "<'a\#{\n1\n}\nb\n'>"
+    assert_interpolates 'single quoted symbol',               ":'a\#{\n1\n}\nb\n'",  "<:'a\#{\n1\n}\nb\n'>"
+    assert_interpolates 'symbol array without interpolation', "%i.a\#{\n1\n}\nb\n.", "<%i.a\#{\n1\n}\nb\n.>"
+    assert_interpolates '%q string without interpolation',    "%q.a\#{\n1\n}\nb\n.", "<%q.a\#{\n1\n}\nb\n.>"
+    assert_interpolates 'string array without interpolation', "%w.a\#{\n1\n}\nb\n.", "<%w.a\#{\n1\n}\nb\n.>"
+  end
+
   describe 'BEGIN/END' do
     # not implemented b/c we cannot wrap around these either.
     # So what does it mean to wrap around?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-17 00:00:00.000000000 Z
+date: 2016-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -161,9 +161,11 @@ files:
 - lib/seeing_is_believing/binary/data_structures.rb
 - lib/seeing_is_believing/binary/engine.rb
 - lib/seeing_is_believing/binary/format_comment.rb
+- lib/seeing_is_believing/binary/interline_align.rb
 - lib/seeing_is_believing/binary/remove_annotations.rb
 - lib/seeing_is_believing/binary/rewrite_comments.rb
 - lib/seeing_is_believing/code.rb
+- lib/seeing_is_believing/customize_pp.rb
 - lib/seeing_is_believing/debugger.rb
 - lib/seeing_is_believing/error.rb
 - lib/seeing_is_believing/evaluate_by_moving_files.rb
@@ -200,6 +202,7 @@ files:
 - spec/hash_struct_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/spec_helper.rb
+- spec/spec_helper_spec.rb
 - spec/wrap_expressions_spec.rb
 homepage: https://github.com/JoshCheek/seeing_is_believing
 licenses:
@@ -261,7 +264,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: seeing_is_believing
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Records results of every line of code in your file
@@ -290,4 +293,5 @@ test_files:
 - spec/hash_struct_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/spec_helper.rb
+- spec/spec_helper_spec.rb
 - spec/wrap_expressions_spec.rb