seeing_is_believing 3.3.0 → 4.0.1

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -4,6 +4,10 @@ require 'seeing_is_believing/event_stream/events'
 require 'seeing_is_believing/error'
 require 'thread'
 
+# Polyfill String#scrub on Ruby 2.0.0
+require 'seeing_is_believing/compatibility'
+using SeeingIsBelieving::Compatibility
+
 class SeeingIsBelieving
   module EventStream
     class Consumer
@@ -60,15 +64,7 @@ class SeeingIsBelieving
         rescue EncodingError
           str = str.force_encoding(Encoding::UTF_8)
         end
-        return str.scrub('�') if str.respond_to? :scrub
-        # basically reimplement scrub, b/c it's not implemented on 2.0.0
-        str.each_char.inject("") do |new_str, char|
-          if char.valid_encoding?
-            new_str << char
-          else
-            new_str << '�'
-          end
-        end
+        str.scrub('�')
       end
 
       def initialize(streams)
@@ -169,51 +165,53 @@ class SeeingIsBelieving
         end
       end
 
-      def extract_token(line)
+      def shift_token(line)
         event_name = line[/[^ ]+/]
         line.sub!(/^\s*[^ ]+\s*/, '')
         event_name
       end
 
       # For a consideration of many different ways of passing the message, see 5633064
-      def extract_string(line)
-        str = Marshal.load extract_token(line).unpack('m0').first
+      def shift_string(line)
+        str = Marshal.load shift_token(line).unpack('m0').first
         Consumer.fix_encoding(str)
       end
 
       def event_for(original_line)
         line       = original_line.chomp
-        event_name = extract_token(line).intern
+        event_name = shift_token(line).intern
         case event_name
         when :result
-          line_number = extract_token(line).to_i
-          type        = extract_token(line).intern
-          inspected   = extract_string(line)
+          line_number = shift_token(line).to_i
+          type        = shift_token(line).intern
+          inspected   = shift_string(line)
           Events::LineResult.new(type: type, line_number: line_number, inspected: inspected)
         when :maxed_result
-          line_number = extract_token(line).to_i
-          type        = extract_token(line).intern
+          line_number = shift_token(line).to_i
+          type        = shift_token(line).intern
           Events::ResultsTruncated.new(type: type, line_number: line_number)
         when :exception
           Events::Exception.new \
-            line_number: extract_token(line).to_i,
-            class_name:  extract_string(line),
-            message:     extract_string(line),
-            backtrace:   extract_token(line).to_i.times.map { extract_string line }
+            line_number: shift_token(line).to_i,
+            class_name:  shift_string(line),
+            message:     shift_string(line),
+            backtrace:   shift_token(line).to_i.times.map { shift_string line }
         when :max_line_captures
-          token = extract_token(line)
+          token = shift_token(line)
           value = token =~ /infinity/i ? Float::INFINITY : token.to_i
           Events::MaxLineCaptures.new(value: value)
         when :num_lines
-          Events::NumLines.new(value: extract_token(line).to_i)
+          Events::NumLines.new(value: shift_token(line).to_i)
         when :sib_version
-          Events::SiBVersion.new(value: extract_string(line))
+          Events::SiBVersion.new(value: shift_string(line))
         when :ruby_version
-          Events::RubyVersion.new(value: extract_string(line))
+          Events::RubyVersion.new(value: shift_string(line))
         when :filename
-          Events::Filename.new(value: extract_string(line))
+          Events::Filename.new(value: shift_string(line))
+        when :file_loaded
+          Events::FileLoaded.new
         when :exec
-          Events::Exec.new(args: extract_string(line))
+          Events::Exec.new(args: shift_string(line))
         else
           raise UnknownEvent, original_line.inspect
         end

data/lib/seeing_is_believing/event_stream/events.rb

@@ -58,6 +58,13 @@ class SeeingIsBelieving
         attributes :value
       end
 
+      # For knowing when you can perform certain tasks (eg moving the file back)
+      class FileLoaded < Event
+        def self.event_name
+          :file_loaded
+        end
+      end
+
       # Number of lines in the program.
       class NumLines < Event
         def self.event_name

data/lib/seeing_is_believing/event_stream/handlers/record_exit_events.rb

@@ -7,8 +7,8 @@ class SeeingIsBelieving
         attr_reader :exitstatus
         attr_reader :timeout_seconds
 
-        def initialize(next_observer)
-          @next_observer = next_observer
+        def initialize(next_handler)
+          @next_handler = next_handler
         end
 
         def call(event)
@@ -18,7 +18,7 @@ class SeeingIsBelieving
           when Events::Timeout
             @timeout_seconds = event.seconds
           end
-          @next_observer.call(event)
+          @next_handler.call(event)
         end
       end
     end

data/lib/seeing_is_believing/event_stream/handlers/update_result.rb

@@ -29,7 +29,8 @@ class SeeingIsBelieving
                Finished,
                StdoutClosed,
                StderrClosed,
-               EventStreamClosed
+               EventStreamClosed,
+               FileLoaded
                # no op
           else raise "Unknown event: #{event.inspect}"
           end

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -7,6 +7,17 @@ using SeeingIsBelieving::Safe
 class SeeingIsBelieving
   module EventStream
     class Producer
+
+      # Guarding against hostile users (e.g. me) that do ridiculous things like blowing away these constants
+      old_w, $-w = $-w, nil # Ruby warns about accessing deprecated constants
+      Object.constants.each do |name|
+        next if name == :SortedSet # Removed in 3.0, but apparently the constant still exists, it just explodes if you reference it
+        const_set name, Object.const_get(name)
+      end
+      $-w = old_w
+
+      ErrnoEPIPE = Errno::EPIPE # not actually tested, but we can see it is referenced below
+
       module NullQueue
         extend self
         Queue.instance_methods(false).each do |name|
@@ -40,6 +51,10 @@ class SeeingIsBelieving
         queue << "max_line_captures #{max_line_captures}"
       end
 
+      def file_loaded
+        queue << "file_loaded"
+      end
+
       StackErrors = [SystemStackError]
       StackErrors << Java::JavaLang::StackOverflowError if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java'
       def record_result(type, line_number, value)
@@ -49,9 +64,13 @@ class SeeingIsBelieving
         if count < max_line_captures
           begin
             if block_given?
-              inspected = yield(value).to_str
+              inspected = yield(value)
             else
-              inspected = value.inspect.to_str
+              inspected = value.inspect
+            end
+            unless String === inspected
+              inspected = inspected.to_str
+              raise unless String === inspected
             end
           rescue *StackErrors
             # this is necessary because SystemStackError won't show the backtrace of the method we tried to call
@@ -76,9 +95,11 @@ class SeeingIsBelieving
       # records the exception, returns the exitstatus for that exception
       def record_exception(line_number, exception)
         return exception.status if SystemExit === exception # TODO === is not in the list
-        if !line_number && filename
-          begin line_number = exception.backtrace.grep(/#{filename.to_s}/).first[/:\d+/][1..-1].to_i
-          rescue NoMethodError
+        unless line_number
+          if filename
+            begin line_number = exception.backtrace.grep(/#{filename.to_s}/).first[/:\d+/][1..-1].to_i
+            rescue NoMethodError
+            end
           end
         end
         line_number ||= -1
@@ -118,6 +139,9 @@ class SeeingIsBelieving
       # for a consideration of many different ways of doing this, see 5633064
       def to_string_token(string)
         [Marshal.dump(string.to_s)].pack('m0')
+      rescue TypeError => err
+        raise unless err.message =~ /singleton can't be dumped/
+        to_string_token string.to_s.dup
       end
 
       def build_producer_thread(resultstream)

data/lib/seeing_is_believing/safe.rb

@@ -1,6 +1,13 @@
 # require this before anything else, b/c it expects the world to be sane when it is loaded
 class SeeingIsBelieving
   module Safe
+
+    # Subclasses must refine before superclasses in older Rubies, otherwise
+    # it finds the superclass method and behaves unexpectedly.
+    refine String.singleton_class do
+      alias === ===
+    end
+
     refine Class do
       alias === ===
     end
@@ -43,13 +50,7 @@ class SeeingIsBelieving
       alias to_str to_str
     end
 
-    # in 2.4 we should use Integer instead, but it's not obvious to me how
-    # to detect this. eg defined?(Fixnum) returns "constant". Accessing it
-    # leads to a warning, but SiB turns warnings off so you don't see it.
-    # So.... for now, it incidentally doesn't do anything annoying, but would
-    # be good to figure out something better (eg if we ever wanted to allow the
-    # user to decide whether warnings should display or not)
-    refine Fixnum do
+    refine Integer do
       alias to_s to_s
       alias next next
       alias <    <

data/lib/seeing_is_believing/swap_files.rb

@@ -0,0 +1,90 @@
+require 'seeing_is_believing/error'
+require 'seeing_is_believing/hard_core_ensure'
+
+class SeeingIsBelieving
+  class SwapFiles
+    # Might honeslty make more sense to break this out into 2 different classes.
+    # We've got to do some confusing state accounting since there are really 2
+    # algorithms here:
+    #
+    # if the file exists:
+    #   make sure there isn't a backup (could cause the user to lose their file)
+    #   back the file up
+    #   write the rewritten code to the file
+    #   if we are told to show the user program
+    #     move the backup over the top of the rewritten file
+    #     do nothing in the ensure block
+    #   else
+    #     in the ensure block: move the backup over the top of the rewritten file
+    # if the file DNE:
+    #   write the rewritten code to the file
+    #   if we are told to show the user program
+    #     write the user program to the file
+    #   delete the file in the ensure block
+    def self.call(*args, &block)
+      new(*args, &block).call
+    end
+
+    def initialize(file_path, backup_path, user_program, rewritten_program, &block)
+      self.file_path         = file_path
+      self.block             = block
+      self.backup_path       = backup_path
+      self.user_program      = user_program
+      self.rewritten_program = rewritten_program
+    end
+
+    def call
+      HardCoreEnsure.call \
+        code: -> {
+          File.exist? backup_path and
+            raise TempFileAlreadyExists.new(file_path, backup_path)
+
+          @has_file = File.exist? file_path
+
+          if @has_file
+            File.rename file_path, backup_path
+            @needs_restore = true
+          end
+
+          save_file rewritten_program
+
+          block.call self
+        },
+        ensure: -> {
+          set_back_to_initial_conditions
+        }
+    end
+
+    def show_user_program
+      if @needs_restore
+        restore
+      else
+        save_file user_program
+      end
+    end
+
+    private
+
+    attr_accessor :block, :file_path, :backup_path, :rewritten_program, :user_program
+
+    def restore
+      File.rename(backup_path, file_path)
+      @needs_restore = false
+    end
+
+
+    def save_file(program)
+      File.open file_path, 'w', external_encoding: "utf-8" do |f|
+        f.write program.to_s
+      end
+    end
+
+    def set_back_to_initial_conditions
+      if @needs_restore
+        restore
+      elsif !@has_file
+        File.delete(file_path)
+      end
+    end
+  end
+end

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.3.0'
+  VERSION = '4.0.1'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -25,25 +25,25 @@ 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!.....'
           when :match_current_line
-            rewriter.insert_before_multi range, '~' # Regexp#~
+            rewriter.insert_before range, '~' # Regexp#~
           end
         end
 
-        wrappings.each do |line_num, (range, last_col, meta)|
-          rewriter.insert_before_multi range, before_each.call(line_num)
+        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)|
-          rewriter.insert_after_multi range, after_each.call(line_num)
+        wrappings.each do |line_num, (range, _last_col, _meta)|
+          rewriter.insert_after range, after_each.call(line_num)
         end
 
-        rewriter.insert_before_multi root_range, before_all.call
-        rewriter.insert_after_multi  root_range, after_all_text
+        rewriter.insert_before root_range, before_all.call
+        rewriter.insert_after  root_range, after_all_text
         rewriter.process
       end
     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