seeing_is_believing 2.1.3 → 2.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 924b2f9837ef55a65692edd1552bb4e28c497e04
-  data.tar.gz: c527cc92aea505196789779036ff2b9fb3265056
+  metadata.gz: 1952064fe97bbd42814728d8562a23f401b11ccc
+  data.tar.gz: 41ebff3b5b92e9003ef4e587d25367a610ea45e3
 SHA512:
-  metadata.gz: a327a0865eb016d325158d9eb17fb34803634e37b2a0c31037df8385f076b3dbb23627c04498b5c9f5d6f4128efa544afe8c90b802536cb194f0b01bed3e53ad
-  data.tar.gz: fb8f88092ae5e16ea2ff1ca5f9ee22f7b993062ab8c67f93a4ec02b6ca3a7b0c8876998ee28e6994cbe6affd2af4ac96f6bcdba0fdefa6c2396df3a252542776
+  metadata.gz: d40b823e70ff45521c324895cde5d0d76195ef26339ba0dc431d6009ec901bcc1e0e9ad509eb752477a3973035b88667ab6e0ef3ca97e354a2c8c90369a3dc2e
+  data.tar.gz: c766a89c201e945347575eed23044fd1635628bfb1b6857bfa4d62bc4641dfe809e15fe91322f7590d344db752e562a533e7d56ce926649befe5e4aa1353b31a

data/.travis.yml

@@ -4,3 +4,12 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.2
+  - ruby-head
+  - rbx-2
+  - jruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx-2

data/Readme.md

@@ -68,6 +68,7 @@ Editor Integration
 * [TextMate 2](https://github.com/JoshCheek/text_mate_2-seeing-is_believing)
 * [vim-ruby-xmpfilter](https://github.com/t9md/vim-ruby-xmpfilter) (has support for `seeing_is_believing`)
 * [vim-seeing-is-believing](https://github.com/hwartig/vim-seeing-is-believing)
+* [atom-seeing-is-believing](https://github.com/JoshCheek/atom-seeing-is-believing) (prob has best installation instructions)
 
 Emacs Integration
 =================

data/features/flags.feature

@@ -561,8 +561,8 @@ Feature: Using flags
     result = SeeingIsBelieving::Result.new
     result.record_result(1, /omg/)
 
-    require 'yaml'
-    puts YAML.dump result
+    require 'json'
+    puts JSON.dump result.to_primitive
     """
     When I run "chmod +x fake_ruby"
     When I run "seeing_is_believing -e 123 --shebang ./fake_ruby"

data/features/regression.feature

@@ -287,3 +287,98 @@ Feature:
     Then stderr includes "1: unterminated string meets end of file"
     And the exit status is 2
     And stdout is empty
+
+  Scenario: A program using system
+    Given the file "invoking_system.rb":
+    """
+    system %(ruby -e '$stdout.puts %(hello)')
+    system %(ruby -e '$stderr.puts %(world)')
+    """
+    When I run "seeing_is_believing invoking_system.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    system %(ruby -e '$stdout.puts %(hello)')  # => true
+    system %(ruby -e '$stderr.puts %(world)')  # => true
+
+    # >> hello
+
+    # !> world
+    """
+
+  Scenario: A program overriding stdout/stderr
+    Given the file "black_hole.rb":
+    """
+    File.open '/dev/null', 'w' do |black_hole|
+      STDERR = $stderr = black_hole
+      STDOUT = $stdout = black_hole
+      puts "You won't see this, it goes into the black hole"
+      system %q(ruby -e '$stdout.puts "stdout gets past it b/c of dumb ruby bug"')
+      system %q(ruby -e '$stderr.puts "stderr gets past it b/c of dumb ruby bug"')
+    end
+    """
+    When I run "seeing_is_believing black_hole.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    File.open '/dev/null', 'w' do |black_hole|                                      # => File
+      STDERR = $stderr = black_hole                                                 # => #<File:/dev/null>
+      STDOUT = $stdout = black_hole                                                 # => #<File:/dev/null>
+      puts "You won't see this, it goes into the black hole"                        # => nil
+      system %q(ruby -e '$stdout.puts "stdout gets past it b/c of dumb ruby bug"')  # => true
+      system %q(ruby -e '$stderr.puts "stderr gets past it b/c of dumb ruby bug"')  # => true
+    end                                                                             # => true
+
+    # >> stdout gets past it b/c of dumb ruby bug
+
+    # !> stderr gets past it b/c of dumb ruby bug
+    """
+
+  Scenario: Incorrect wrapping in some programs
+    Given the file "incorrect_wrapping.rb":
+    """
+    a
+    class B
+      def c
+        d = 1
+      end
+    end
+    """
+    When I run "seeing_is_believing incorrect_wrapping.rb"
+    Then stderr is empty
+    And the exit status is 1
+    And stdout is:
+    """
+    a          # ~> NameError: undefined local variable or method `a' for main:Object
+    class B
+      def c
+        d = 1
+      end
+    end
+
+    # ~> NameError
+    # ~> undefined local variable or method `a' for main:Object
+    # ~>
+    # ~> incorrect_wrapping.rb:1:in `<main>'
+    """
+
+  Scenario: Can deal with hostile environments
+    Given the file "bang_object.rb":
+    """
+    class Object
+      def !(a)
+      end
+    end
+    """
+    When I run "seeing_is_believing bang_object.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    class Object
+      def !(a)
+      end
+    end
+    """

data/features/support/env.rb

@@ -8,12 +8,12 @@ end
 
 
 Then 'stdout is exactly:' do |code|
-  @last_executed.stdout.should == eval_curlies(code)
+  expect(@last_executed.stdout).to eq eval_curlies(code)
 end
 
 Then 'stdout is the JSON:' do |json|
   require 'json'
   expected = JSON.parse(json)
   actual   = JSON.parse(@last_executed.stdout)
-  actual.should == expected
+  expect(actual).to eq expected
 end

data/lib/seeing_is_believing.rb

@@ -52,10 +52,12 @@ class SeeingIsBelieving
     WrapExpressions.call "#{@program}\n",
                          before_all:  "begin; $SiB.number_of_captures = #{number_of_captures_as_str}; ",
                          after_all:   ";rescue Exception;"\
-                                        "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;"\
+                                        "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",
                          before_each: -> line_number { "$SiB.record_result(#{line_number}, (" },
                          after_each:  -> line_number { "))" }

data/lib/seeing_is_believing/binary/clean_body.rb

@@ -22,7 +22,7 @@ class SeeingIsBelieving
         buffer, parser, rewriter = ParserHelpers.initialize_parser code, 'strip_comments'
         comments                 = ParserHelpers.comments_from parser, buffer
 
-        removed_comments      = { result: [], exception: [], stdout: [], stderr: [] }
+        removed_comments         = { result: [], exception: [], stdout: [], stderr: [] }
 
         comments.each do |comment|
           case comment.text

data/lib/seeing_is_believing/binary/comment_formatter.rb

@@ -1,5 +1,12 @@
 class SeeingIsBelieving
   class Binary
+    # not sure I like this name, it formats comments that
+    # show results e.g. "# => [1, 2, 3]"
+    #
+    # line_length is the length of the line this comment is being appended to
+    #
+    # For examples of what the options are, and how they all fit together, see
+    # spec/binary/comment_formatter_spec.rb
     class CommentFormatter
       def self.call(*args)
         new(*args).call
@@ -48,7 +55,7 @@ class SeeingIsBelieving
       end
 
       def ellipsify(string)
-        string.sub(/.{0,3}$/) { |last_chars| last_chars.gsub /./, '.' }
+        string.sub(/.{0,3}$/) { |last_chars| '.' * last_chars.size }
       end
     end
   end

data/lib/seeing_is_believing/binary/comment_lines.rb

@@ -1,6 +1,7 @@
 require 'seeing_is_believing/binary/commentable_lines'
 
 class SeeingIsBelieving
+  # spec/binary/comment_lines_spec.rb
   class Binary
 
     # takes a body and a block

data/lib/seeing_is_believing/binary/commentable_lines.rb

@@ -4,6 +4,9 @@ class SeeingIsBelieving
   class Binary
 
     # could possibly be sped up by just reflecting on the tokens instead of the whole ast
+    #
+    # specs for this class are in spec/binary/comment_lines_spec.rb
+    # because it was extracted from that class
     class CommentableLines
 
       include ParserHelpers

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -11,7 +11,7 @@
 # read the wrong file... of course, since we rewrite the file,
 # its body will be incorrect, anyway.
 
-require 'yaml'
+require 'json'
 require 'open3'
 require 'timeout'
 require 'stringio'
@@ -137,7 +137,7 @@ class SeeingIsBelieving
     end
 
     def deserialize_result
-      YAML.load stdout
+      Result.from_primitive JSON.load stdout
     end
 
     def wrap_error(error)

data/lib/seeing_is_believing/has_exception.rb

@@ -2,7 +2,23 @@ class SeeingIsBelieving
 
   # We cannot serialize the actual exception because we do not have any guarantee that its class is defined on the SIB side,
   # so we must use simpler data structures (Strings and arrays)
-  RecordedException = Struct.new :class_name, :message, :backtrace
+  RecordedException = Struct.new :class_name, :message, :backtrace do
+    def self.from_primitive(primitive)
+      return nil unless primitive
+      exception = new
+      exception.class_name = primitive['class_name']
+      exception.message    = primitive['message']
+      exception.backtrace  = primitive['backtrace']
+      exception
+    end
+
+    def to_primitive
+      { 'class_name' => class_name,
+        'message'    => message,
+        'backtrace'  => backtrace,
+      }
+    end
+  end
 
   module HasException
     attr_accessor :exception

data/lib/seeing_is_believing/line.rb

@@ -14,6 +14,33 @@ class SeeingIsBelieving
       end
     end
 
+    def to_float(n)
+      return n unless n == Float::INFINITY
+      'FUCKING_INFINITY_AND_JESUS_FUCKING_CHRIST_JSON_AND_MARSHAL_AND_YAML_WHAT_THE_FUCK?'
+    end
+
+    def from_float(n)
+      return n if n.kind_of? Float
+      Float::INFINITY
+    end
+
+    def to_primitive
+      { 'array'                  => @array,
+        'max_number_of_captures' => to_float(@max_number_of_captures),
+        'num_results'            => @num_results,
+        'total_size'             => @total_size,
+        'exception'              => (exception && exception.to_primitive)
+      }
+    end
+
+    def from_primitive(primitive)
+      @array                  = primitive['array']
+      @max_number_of_captures = from_float primitive['max_number_of_captures']
+      @num_results            = primitive['num_results']
+      @total_size             = primitive['total_size']
+      @exception              = RecordedException.from_primitive primitive['exception']
+    end
+
     def to_a
       @array.dup
     end
@@ -32,6 +59,12 @@ class SeeingIsBelieving
         inspected = value.inspect.to_str # only invoke inspect once, b/c the inspection may be recorded
       rescue NoMethodError
         inspected = "#<no inspect available>"
+      rescue SystemStackError
+        # this is necessary because SystemStackError won't show the backtrace of the method we tried to call
+        # which means there won't be anything showing the user where this came from
+        # so we need to re-raise the error to get a backtrace that shows where we came from
+        # otherwise it looks like the bug is in SiB and not the user's program, see https://github.com/JoshCheek/seeing_is_believing/issues/37
+        raise SystemStackError, "Calling inspect blew the stack (is it recursive w/o a base case?)"
       end
 
       if    size <  @max_number_of_captures then @array << inspected

data/lib/seeing_is_believing/result.rb

@@ -6,6 +6,37 @@ class SeeingIsBelieving
     include HasException
     include Enumerable
 
+    def self.from_primitive(primitive)
+      new.from_primitive(primitive)
+    end
+
+    def from_primitive(primitive)
+      self.exitstatus = primitive['exitstatus']
+      self.stdout     = primitive['stdout']
+      self.stderr     = primitive['stderr']
+      self.bug_in_sib = primitive['bug_in_sib']
+      self.exception  = RecordedException.from_primitive primitive['exception']
+      primitive['results'].each do |line_number, primitive_line|
+        results_for(line_number.to_i).from_primitive(primitive_line)
+      end
+      self
+    end
+
+    def to_primitive
+      primitive = {
+        'exitstatus' => exitstatus,
+        'stdout'     => stdout,
+        'stderr'     => stderr,
+        'bug_in_sib' => bug_in_sib,
+        'exception'  => (exception && exception.to_primitive),
+      }
+      primitive['results'] = results.each_with_object({}) do |(line_number, line), r|
+        r[line_number] = line.to_primitive
+      end
+      primitive
+    end
+
+
     attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib, :number_of_captures
 
     alias bug_in_sib? bug_in_sib

data/lib/seeing_is_believing/the_matrix.rb

@@ -1,24 +1,40 @@
 # WARNING: DO NOT REQUIRE THIS FILE, IT WILL FUCK YOU UP!!!!!!
 
+# READ THIS IF YOU WANT TO USE YOUR OWN MATRIX FILE:
+# https://github.com/JoshCheek/seeing_is_believing/issues/24
+#
+# (or if you want to understand why we do the pipe dance)
 
-require 'yaml'
-require 'stringio'
-real_stdout = STDOUT
-real_stderr = STDERR
-STDOUT = $stdout = fake_stdout = StringIO.new
-STDERR = $stderr = fake_stderr = StringIO.new
 
+require 'json'
 require 'seeing_is_believing/result'
 $SiB = SeeingIsBelieving::Result.new
 
+stdout_real_obj = STDOUT      # the real Ruby object, but its FD is going to keep getting reopened
+stderr_real_obj = STDERR
+stdout_real_fd  = STDOUT.dup  # duped Ruby object, but with the real file descriptor
+stderr_real_fd  = STDERR.dup
+
+read_from_mock_out, write_to_mock_out = IO.pipe
+read_from_mock_err, write_to_mock_err = IO.pipe
+
+stdout_real_obj.reopen write_to_mock_out
+stderr_real_obj.reopen write_to_mock_err
+
 at_exit do
-  $SiB.stdout = fake_stdout.string
-  $SiB.stderr = fake_stderr.string
+  stdout_real_obj.reopen stdout_real_fd
+  stderr_real_obj.reopen stderr_real_fd
+  write_to_mock_out.close unless write_to_mock_out.closed?
+  write_to_mock_err.close unless write_to_mock_err.closed?
+  $SiB.stdout = read_from_mock_out.read
+  $SiB.stderr = read_from_mock_err.read
+  read_from_mock_out.close
+  read_from_mock_err.close
 
   $SiB.exitstatus ||= 0
   $SiB.exitstatus   = 1         if $!
   $SiB.exitstatus   = $!.status if $!.kind_of? SystemExit
   $SiB.bug_in_sib   = $! && ! $!.kind_of?(SystemExit)
 
-  real_stdout.write YAML.dump $SiB
+  stdout_real_fd.write JSON.dump $SiB.to_primitive
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '2.1.3'
+  VERSION = '2.1.4'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -41,10 +41,7 @@ class SeeingIsBelieving
             rewriter.insert_after  range, after_each.call(line_num)
           end
 
-          # another stupid hack to get around a heredoc at the end of the document
-          # hopefully we can remove this after next version of Parser is released
-          last_index, (range, col) = wrappings.max_by(&:first)
-          range ||= root.location.expression
+          range = root.location.expression
           rewriter.insert_after range, after_all
         end
 
@@ -141,16 +138,23 @@ class SeeingIsBelieving
           add_to_wrappings range
           add_children ast.children.last
         end
-      when :lvasgn, :ivasgn, :gvasgn, :cvasgn, :casgn # local variable, instance variable, global variable, class variable, constant
+      when :lvasgn,   # a   = 1
+           :ivasgn,   # @a  = 1
+           :gvasgn,   # $a  = 1
+           :cvasgn,   # @@a = 1
+           :casgn,    # A   = 1
+           :or_asgn,  # a ||= b
+           :and_asgn, # a &&= b
+           :op_asgn   # a += b, a -= b, a *= b, etc
+
         # because the RHS can be a heredoc, and parser currently handles heredocs locations incorrectly
         # we must hack around this
-
         if ast.children.last.kind_of? ::AST::Node
           begin_pos = ast.location.expression.begin_pos
           end_pos   = heredoc_hack(ast.children.last).location.expression.end_pos
           range     = Parser::Source::Range.new buffer, begin_pos, end_pos
           add_to_wrappings range
-          add_children ast
+          add_children ast, true
         end
       when :send
         # because the target and the last child can be heredocs
@@ -160,7 +164,11 @@ class SeeingIsBelieving
         range = ast.location.expression
 
         # first two children: target, message, so we want the last child only if it is an argument
-        target, message, *, last_arg = ast.children
+        children = ast.children
+        target   = children[0]
+        message  = children[1]
+        last_arg = children.size > 2 ? children[-1] : nil
+
 
         # last arg is a heredoc, use the closing paren, or the end of the first line of the heredoc
         if heredoc? last_arg