seeing_is_believing 3.0.1 → 3.1.0

data/lib/seeing_is_believing/customize_pp.rb

@@ -0,0 +1,5 @@
+class String
+  def pretty_print(pp)
+    pp.text inspect.gsub(/\\n(?!")/, '\n" +'+"\n"+'"')
+  end
+end

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -56,15 +56,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 1.9.3
-        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)
@@ -74,39 +66,40 @@ class SeeingIsBelieving
         event_stream         = streams.fetch :events
         stdout_stream        = streams.fetch :stdout
         stderr_stream        = streams.fetch :stderr
-
-        Thread.new do
-          begin
-            stdout_stream.each_line { |line| queue << Events::Stdout.new(value: line) }
-            queue << Events::StdoutClosed.new(side: :producer)
-          rescue IOError
-            queue << Events::StdoutClosed.new(side: :consumer)
-          ensure
-            queue << lambda { finish_criteria.stdout_thread_finished! }
-          end
-        end
-
-        Thread.new do
-          begin
-            stderr_stream.each_line { |line| queue << Events::Stderr.new(value: line) }
-            queue << Events::StderrClosed.new(side: :producer)
-          rescue IOError
-            queue << Events::StderrClosed.new(side: :consumer)
-          ensure
-            queue << lambda { finish_criteria.stderr_thread_finished! }
-          end
-        end
-
-        Thread.new do
-          begin
-            event_stream.each_line { |line| queue << line }
-            queue << Events::EventStreamClosed.new(side: :producer)
-          rescue IOError
-            queue << Events::EventStreamClosed.new(side: :consumer)
-          ensure
-            queue << lambda { finish_criteria.event_thread_finished! }
-          end
-        end
+        self.threads         = [
+          Thread.new do
+            begin
+              stdout_stream.each_line { |line| queue << Events::Stdout.new(value: line) }
+              queue << Events::StdoutClosed.new(side: :producer)
+            rescue IOError
+              queue << Events::StdoutClosed.new(side: :consumer)
+            ensure
+              queue << lambda { finish_criteria.stdout_thread_finished! }
+            end
+          end,
+
+          Thread.new do
+            begin
+              stderr_stream.each_line { |line| queue << Events::Stderr.new(value: line) }
+              queue << Events::StderrClosed.new(side: :producer)
+            rescue IOError
+              queue << Events::StderrClosed.new(side: :consumer)
+            ensure
+              queue << lambda { finish_criteria.stderr_thread_finished! }
+            end
+          end,
+
+          Thread.new do
+            begin
+              event_stream.each_line { |line| queue << line }
+              queue << Events::EventStreamClosed.new(side: :producer)
+            rescue IOError
+              queue << Events::EventStreamClosed.new(side: :consumer)
+            ensure
+              queue << lambda { finish_criteria.event_thread_finished! }
+            end
+          end,
+        ]
       end
 
       def call(n=1)
@@ -135,10 +128,13 @@ class SeeingIsBelieving
         }
       end
 
+      def join
+        threads.each(&:join)
+      end
 
       private
 
-      attr_accessor :queue, :finish_criteria
+      attr_accessor :queue, :finish_criteria, :threads
 
       def next_event
         raise NoMoreEvents if @finished

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -1,29 +1,27 @@
-require 'seeing_is_believing/event_stream/events'
 require 'seeing_is_believing/safe'
-require 'thread'
+require 'seeing_is_believing/event_stream/events'
+require 'thread' # <-- do we still need this?
+
+using SeeingIsBelieving::Safe
 
 class SeeingIsBelieving
   module EventStream
     class Producer
       module NullQueue
         extend self
-        def <<(*)   end
-        def shift() end
-        # TODO: this one doesn't have clear, but we can call that on the real one.
-        # find a way to test this situation?
+        Queue.instance_methods.each do |name|
+          define_method(name) { |*| }
+        end
       end
 
       attr_accessor :max_line_captures, :filename
 
       def initialize(resultstream)
-        resultstream           = Safe::Stream[resultstream]
         self.filename          = nil
         self.max_line_captures = Float::INFINITY
         self.recorded_results  = []
-        self.queue             = Safe::Queue[Queue.new]
-        self.producer_thread   = Safe::Thread[
-          build_producer_thread(resultstream)
-        ]
+        self.queue             = Queue.new
+        self.producer_thread   = build_producer_thread(resultstream)
       end
 
       attr_reader :version
@@ -45,7 +43,7 @@ class SeeingIsBelieving
       StackErrors = [SystemStackError]
       StackErrors << Java::JavaLang::StackOverflowError if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java'
       def record_result(type, line_number, value)
-        counts = recorded_results[line_number] ||= Safe::Hash.new(0)
+        counts = recorded_results[line_number] ||= Hash.new(0)
         count  = counts[type]
         recorded_results[line_number][type] = count.next
         if count < max_line_captures
@@ -64,33 +62,30 @@ class SeeingIsBelieving
           rescue Exception
             inspected = "#<no inspect available>"
           end
-          queue << "result #{line_number} #{type} #{to_string_token inspected}"
+          queue << "result #{line_number.to_s} #{type.to_s} #{to_string_token inspected}"
         elsif count == max_line_captures
-          queue << "maxed_result #{line_number} #{type}"
+          queue << "maxed_result #{line_number.to_s} #{type.to_s}"
         end
         value
       end
 
       # records the exception, returns the exitstatus for that exception
       def record_exception(line_number, exception)
-        return exception.status if SystemExit === exception
-        exception = Safe::Exception[exception]
+        return exception.status if SystemExit === exception # TODO === is not in the list
         if !line_number && filename
-          begin line_number = exception.backtrace.grep(/#{filename}/).first[/:\d+/][1..-1].to_i
+          begin line_number = exception.backtrace.grep(/#{filename.to_s}/).first[/:\d+/][1..-1].to_i
           rescue NoMethodError
           end
         end
         line_number ||= -1
-        queue << Safe::Array[[
+        queue << [
           "exception",
-          Safe::Fixnum[line_number],
+          line_number.to_s,
           to_string_token(exception.class.name),
           to_string_token(exception.message),
-          Safe::Fixnum[
-            Safe::Array[exception.backtrace].size
-          ],
-          *Safe::Array[exception.backtrace].map { |line| to_string_token line }
-        ]].join(" ")
+          exception.backtrace.size.to_s,
+          *exception.backtrace.map { |line| to_string_token line }
+        ].join(" ")
         1 # exit status
       end
 
@@ -108,7 +103,7 @@ class SeeingIsBelieving
       end
 
       def finish!
-        queue << :break # note that consumer will continue reading until stream is closed
+        queue << :break # note that consumer will continue reading until stream is closed, which is not the responsibility of the producer
         producer_thread.join
       end
 
@@ -118,17 +113,17 @@ class SeeingIsBelieving
 
       # for a consideration of many different ways of doing this, see 5633064
       def to_string_token(string)
-        Safe::Array[[Safe::Marshal.dump(Safe::String[string].to_s)]].pack('m0')
+        [Marshal.dump(string.to_s)].pack('m0')
       end
 
       def build_producer_thread(resultstream)
         ::Thread.new {
-          Safe::Thread.current.abort_on_exception = true
+          Thread.current.abort_on_exception = true
           begin
             resultstream.sync = true
             loop do
               to_publish = queue.shift
-              break if Safe::Symbol[:break] == to_publish
+              break if :break == to_publish
               resultstream << (to_publish << "\n")
             end
           rescue IOError, Errno::EPIPE
@@ -147,9 +142,7 @@ class SeeingIsBelieving
         loop { break if queue.shift == :fork }
 
         # recreate the thread since forking in Ruby kills threads
-        @producer_thread = Safe::Thread[
-          build_producer_thread(resultstream)
-        ]
+        @producer_thread = build_producer_thread(resultstream)
       end
 
     end

data/lib/seeing_is_believing/safe.rb

@@ -1,43 +1,97 @@
+# require this before anything else, b/c it expects the world to be sane when it is loaded
 class SeeingIsBelieving
   module Safe
-    def self.build(klass, *method_names)
-      options = {}
-      options = method_names.pop if method_names.last.kind_of? ::Hash
-
-      Class.new do
-        class << self
-          alias [] new
-        end
-
-        define_method :initialize do |instance|
-          @_instance = instance
-        end
-
-        methods = method_names.map { |name| [name, klass.instance_method(name)] }
-        methods.each do |name, method|
-          define_method(name) do |*args, &block|
-            method.bind(@_instance).call(*args, &block)
-          end
-        end
-
-        singleton_methods = options.fetch(:class, []).map { |name| [name, klass.method(name)] }
-        singleton_methods.each do |name, method|
-          define_singleton_method name do |*args, &block|
-            method.call(*args, &block)
-          end
-        end
-      end
-    end
-
-    Queue     = build ::Queue, :<<, :shift, :clear
-    Stream    = build ::IO, :sync=, :<<, :flush, :close
-    Symbol    = build ::Symbol, :==, class: [:define_method]
-    String    = build ::String, :to_s
-    Fixnum    = build ::Fixnum, :to_s
-    Array     = build ::Array, :pack, :map, :size, :join
-    Hash      = build ::Hash, :[], :[]=, class: [:new]
-    Marshal   = build ::Marshal, class: [:dump]
-    Exception = build ::Exception, :message, :backtrace, :class, class: [:define_method]
-    Thread    = build ::Thread, :join, class: [:current]
+    refine Class do
+      alias === ===
+    end
+
+    refine Queue do
+      alias <<    <<
+      alias shift shift
+      alias clear clear
+    end
+
+    refine IO do
+      alias sync= sync=
+      alias <<    <<
+      alias flush flush
+      alias close close
+    end
+
+    refine Symbol do
+      alias ==      ==
+      alias to_s    to_s
+      alias inspect inspect
+    end
+
+    refine Symbol.singleton_class do
+      alias define_method define_method
+      alias class_eval    class_eval
+    end
+
+    refine String do
+      alias ==     ==
+      alias to_s   to_s
+      alias to_str to_str
+    end
+
+    refine Fixnum do
+      alias to_s to_s
+      alias next next
+      alias <    <
+    end
+
+    refine Array do
+      alias pack pack
+      alias map  map
+      alias size size
+      alias join join
+      alias []   []
+      alias []=  []=
+    end
+
+    refine Hash do
+      alias []  []
+      alias []= []=
+    end
+
+    refine Hash.singleton_class do
+      alias new new
+    end
+
+    refine Marshal.singleton_class do
+      alias dump dump
+    end
+
+    refine Exception do
+      alias message   message
+      alias backtrace backtrace
+      alias class     class
+    end
+
+    refine Exception.singleton_class do
+      alias define_method define_method
+      alias class_eval    class_eval
+    end
+
+    refine Thread do
+      alias join join
+    end
+
+    refine Thread.singleton_class do
+      alias current current
+    end
+
+    refine Method do
+      alias call call
+    end
+
+    refine Proc do
+      alias call call
+    end
+
+    refine Object do
+      alias block_given? block_given?
+    end
   end
 end

data/lib/seeing_is_believing/the_matrix.rb

@@ -1,7 +1,9 @@
-require_relative 'version'
 require_relative 'safe'
+require_relative 'version'
 require_relative 'event_stream/producer'
 
+using SeeingIsBelieving::Safe
+
 sib_vars     = Marshal.load ENV["SIB_VARIABLES.MARSHAL.B64"].unpack('m0').first
 event_stream = IO.open sib_vars.fetch(:event_stream_fd), "w"
 $SiB = SeeingIsBelieving::EventStream::Producer.new(event_stream)
@@ -12,12 +14,11 @@ $SiB.record_num_lines         sib_vars.fetch(:num_lines)
 $SiB.record_max_line_captures sib_vars.fetch(:max_line_captures)
 
 STDOUT.sync = true
-stdout = SeeingIsBelieving::Safe::Stream[STDOUT]
-stderr = SeeingIsBelieving::Safe::Stream[STDERR]
+stdout, stderr = STDOUT, STDERR
 
 finish = lambda do
   $SiB.finish!
-  SeeingIsBelieving::Safe::Stream[event_stream].close
+  event_stream.close
   stdout.flush
   stderr.flush
 end
@@ -56,16 +57,15 @@ Kernel.define_singleton_method  :fork, &fork_defn
 Process.define_singleton_method :fork, &fork_defn
 
 
-# Some things need to just be recorded and readded as they are called from Ruby C code
+# Some things need to be recorded and readded as they are called from Ruby C code and it blows up in really difficult to dianose ways -.-
 symbol_to_s         = Symbol.instance_method(:to_s)
 exception_message   = Exception.instance_method(:message)
-# exception_backtrace = Exception.instance_method(:backtrace)
+exception_backtrace = Exception.instance_method(:backtrace)
 
 at_exit do
-  # SeeingIsBelieving::Safe::Exception.define_method :backtrace, exception_backtrace
-  SeeingIsBelieving::Safe::Exception.define_method :message,   exception_message
-  SeeingIsBelieving::Safe::Symbol.define_method    :to_s,      symbol_to_s
-
+  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 }
   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.0.1'
+  VERSION = '3.1.0'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -93,6 +93,12 @@ class SeeingIsBelieving
         .each { |child| wrap_recursive child }
     end
 
+    def add_interpolations_in(ast)
+      ast.children
+         .select { |child| child.type == :begin }
+         .each { |child| add_children child }
+    end
+
     def wrap_recursive(ast)
       return wrappings unless ast.kind_of? ::AST::Node
       case ast.type
@@ -128,7 +134,22 @@ class SeeingIsBelieving
       when :array
         add_to_wrappings ast
         the_begin = ast.location.begin
-        add_children ast if the_begin && the_begin.source !~ /\A%/
+        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)
+        elsif the_begin.source !~ /\A%/
+          # normal array
+          add_children ast
+        elsif the_begin.source =~ /\A%/
+          # array of literals
+
+          ast.children.each do |child|
+            t = child.type
+            if t == :dsym || t == :dstr
+              add_interpolations_in child
+            end
+          end
+        end
       when :block
         add_to_wrappings ast
 
@@ -205,11 +226,9 @@ class SeeingIsBelieving
       when :str
         add_to_wrappings ast
 
-      when :dstr, :regexp
+      when :regexp, :dstr, :xstr, :dsym
         add_to_wrappings ast
-        ast.children
-           .select { |child| child.type == :begin }
-           .each { |child| add_children child }
+        add_interpolations_in ast
 
       when :hash
         # method arguments might not have braces around them