andyw8-seeing_is_believing 4.2.0

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

@@ -0,0 +1,23 @@
+require 'json'
+class SeeingIsBelieving
+  module EventStream
+    module Handlers
+      class StreamJsonEvents
+        attr_reader :stream
+
+        def initialize(stream)
+          @flush          = true if stream.respond_to? :flush
+          @stream         = stream
+          @has_exception  = false
+          @exitstatus     = :not_yet_seen
+        end
+
+        def call(event)
+          @stream << JSON.dump(event.as_json)
+          @stream << "\n"
+          @stream.flush if @flush
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'seeing_is_believing/event_stream/events'
+class SeeingIsBelieving
+  module EventStream
+    module Handlers
+      class UpdateResult
+        include EventStream::Events
+
+        attr_reader :result
+
+        def initialize(result)
+          @result = result
+        end
+
+        def call(event)
+          case event
+          when LineResult       then result.record_result(event.type, event.line_number, event.inspected)
+          when ResultsTruncated then result.record_result(event.type, event.line_number, '...') # <-- is this really what I want?
+          when Exception        then result.record_exception event.line_number, event.class_name, event.message, event.backtrace
+          when Stdout           then result.stdout            << event.value
+          when Stderr           then result.stderr            << event.value
+          when MaxLineCaptures  then result.max_line_captures = event.value
+          when Exitstatus       then result.exitstatus        = event.value
+          when NumLines         then result.num_lines         = event.value
+          when SiBVersion       then result.sib_version       = event.value
+          when RubyVersion      then result.ruby_version      = event.value
+          when Filename         then result.filename          = event.value
+          when Timeout          then result.timeout_seconds   = event.seconds
+          when Exec,
+               Finished,
+               StdoutClosed,
+               StderrClosed,
+               EventStreamClosed,
+               FileLoaded
+               # no op
+          else raise "Unknown event: #{event.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -0,0 +1,178 @@
+require 'seeing_is_believing/safe'
+require 'seeing_is_believing/event_stream/events'
+require 'thread' # <-- do we still need this?
+
+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|
+          define_method(name) { |*| }
+        end
+      end
+
+      attr_accessor :max_line_captures, :filename
+
+      def initialize(resultstream)
+        self.filename          = nil
+        self.max_line_captures = Float::INFINITY
+        self.recorded_results  = []
+        self.queue             = Queue.new
+        self.producer_thread   = build_producer_thread(resultstream)
+      end
+
+      attr_reader :version
+      alias ver version
+      def record_sib_version(sib_version)
+        @version = sib_version
+        queue << "sib_version #{to_string_token sib_version}"
+      end
+
+      def record_ruby_version(ruby_version)
+        queue << "ruby_version #{to_string_token ruby_version}"
+      end
+
+      def record_max_line_captures(max_line_captures)
+        self.max_line_captures = max_line_captures
+        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)
+        counts = recorded_results[line_number] ||= Hash.new(0)
+        count  = counts[type]
+        recorded_results[line_number][type] = count.next
+        if count < max_line_captures
+          begin
+            if block_given?
+              inspected = yield(value)
+            else
+              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
+            # 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?)"
+          rescue Exception
+            begin
+              inspected = Kernel.instance_method(:inspect).bind(value).call
+            rescue Exception
+              inspected = "#<no inspect available>"
+            end
+          end
+          queue << "result #{line_number.to_s} #{type.to_s} #{to_string_token inspected}"
+        elsif count == max_line_captures
+          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 # TODO === is not in the list
+        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
+        queue << [
+          "exception",
+          line_number.to_s,
+          to_string_token(exception.class.name),
+          to_string_token(exception.message),
+          exception.backtrace.size.to_s,
+          *exception.backtrace.map { |line| to_string_token line }
+        ].join(" ")
+        1 # exit status
+      end
+
+      def record_filename(filename)
+        self.filename = filename
+        queue << "filename #{to_string_token filename}"
+      end
+
+      def record_exec(args)
+        queue << "exec #{to_string_token args.inspect}"
+      end
+
+      def record_num_lines(num_lines)
+        queue << "num_lines #{num_lines}"
+      end
+
+      def finish!
+        queue << :break # note that consumer will continue reading until stream is closed, which is not the responsibility of the producer
+        producer_thread.join
+      end
+
+      private
+
+      attr_accessor :resultstream, :queue, :producer_thread, :recorded_results
+
+      # 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)
+        ::Thread.new {
+          Thread.current.abort_on_exception = true
+          begin
+            resultstream.sync = true
+            loop do
+              to_publish = queue.shift
+              break if :break == to_publish
+              resultstream << (to_publish << "\n")
+            end
+          rescue IOError, Errno::EPIPE
+            queue.clear
+          ensure
+            self.queue = NullQueue
+            resultstream.flush rescue nil
+          end
+        }
+      end
+
+      def forking_occurred_and_you_are_the_child(resultstream)
+        # clear the queue b/c we don't want to report the same lines 2x,
+        # parent process can report them
+        queue << :fork
+        loop { break if queue.shift == :fork }
+
+        # recreate the thread since forking in Ruby kills threads
+        @producer_thread = build_producer_thread(resultstream)
+      end
+
+    end
+  end
+end

data/lib/seeing_is_believing/hard_core_ensure.rb

@@ -0,0 +1,58 @@
+class SeeingIsBelieving
+  class HardCoreEnsure
+    def self.call(options)
+      new(options).call
+    end
+
+    def initialize(options)
+      self.options = options
+      validate_options
+    end
+
+    def call
+      trap_sigint
+      invoke_code
+    ensure
+      invoke_ensure
+    end
+
+    private
+
+    attr_accessor :options, :ensure_invoked, :old_handler
+
+    def trap_sigint
+      self.old_handler = trap 'INT' do
+        invoke_ensure
+        Process.kill 'INT', $$
+      end
+      trap 'INT', old_handler if ignore_interrupt? old_handler
+    end
+
+    def invoke_code
+      options[:code].call
+    end
+
+    def invoke_ensure
+      return if ensure_invoked
+      self.ensure_invoked = true
+      trap 'INT', old_handler
+      options[:ensure].call
+    end
+
+    def validate_options
+      raise ArgumentError, "Must pass the :code key"   unless options.key? :code
+      raise ArgumentError, "Must pass the :ensure key" unless options.key? :ensure
+      unknown_keys = options.keys - [:code, :ensure]
+      if options.size == 3
+        raise ArgumentError, "Unknown key: #{unknown_keys.first.inspect}"
+      elsif options.size > 3
+        raise ArgumentError, "Unknown keys: #{unknown_keys.map(&:inspect).join(', ')}"
+      end
+    end
+
+    def ignore_interrupt?(interrupt_handler)
+      # any handler that ignores gets normalized to IGNORE
+      interrupt_handler == 'IGNORE'
+    end
+  end
+end

data/lib/seeing_is_believing/hash_struct.rb

@@ -0,0 +1,206 @@
+class SeeingIsBelieving
+  HashStruct = Class.new
+
+  class << HashStruct
+    NoDefault = Module.new
+
+    def init_blocks
+      @init_blocks ||= {}
+    end
+
+    def attribute(name, value=NoDefault, &init_block)
+      init_blocks.key?(name) && raise(ArgumentError, "#{name} was already defined")
+      name.kind_of?(Symbol)  || raise(ArgumentError, "#{name.inspect} should have been a symbol")
+
+      init_block ||= lambda do |hash_struct|
+        if value == NoDefault
+          raise ArgumentError, "Must provide a value for #{name.inspect}"
+        else
+          value
+        end
+      end
+      init_blocks[name] = init_block
+      define_method(name) { self[name] }
+      define_method(:"#{name}=") { |val| self[name] = val }
+
+      self
+    end
+
+    def attributes(*names_or_pairs)
+      names_or_pairs.each do |norp|
+        case norp
+        when Symbol then attribute(norp)
+        else norp.each { |name, default| attribute name, default }
+        end
+      end
+      self
+    end
+
+    def predicate(name, *rest, &b)
+      attribute name, *rest, &b
+      define_method(:"#{name}?") { !!self[name] }
+      self
+    end
+
+    def predicates(*names_or_pairs)
+      names_or_pairs.each do |name_or_pairs|
+        name = pairs = name_or_pairs
+        name_or_pairs.kind_of?(Symbol) ?
+          predicate(name) :
+          pairs.each { |name, default| predicate name, default }
+      end
+      self
+    end
+
+    def anon(&block)
+      Class.new self, &block
+    end
+
+    def for(*attributes_args, &block)
+      anon(&block).attributes(*attributes_args)
+    end
+
+    def for?(*predicate_args, &block)
+      anon(&block).predicates(*predicate_args)
+    end
+  end
+
+  class HashStruct
+    def self.inspect
+      name || "HashStruct.anon"
+    end
+
+    # This could support dynamic attributes very easily
+    # ie they are calculated, but appear as a value (e.g. in to_hash)
+    # not sure how to deal with the fact that they could be assigned, though
+    class Attr
+      def initialize(instance, value=nil, &block)
+        @instance = instance
+        @block    = block if block
+        @value    = value unless block
+      end
+      def value
+        return @value if defined? @value
+        @value = @block.call(@instance)
+      end
+    end
+
+    # The aggressivenes of this is kind of annoying when you're trying to build up a large hash of values
+    # maybe new vs new! one validates arg presence,
+    # maybe a separate #validate! method for that?
+    def initialize(initial_values={}, &initializer)
+      initial_values.respond_to?(:each) ||
+        raise(ArgumentError, "#{self.class.inspect} expects to be initialized with a hash-like object, but got #{initial_values.inspect}")
+      @attributes = self
+        .class
+        .ancestors
+        .take_while { |ancestor| ancestor != HashStruct }
+        .map(&:init_blocks)
+        .reverse
+        .inject({}, :merge)
+        .each_with_object({}) { |(name, block), attrs| attrs[name] = Attr.new(self, &block) }
+      initial_values.each { |key, value| self[key] = value }
+      initializer.call self if initializer
+      each { } # access each key to see if it blows up
+    end
+
+    include Enumerable
+    def each(&block)
+      return to_enum :each unless block
+      @attributes.keys.each do |name|
+        block.call(name, self[name])
+      end
+    end
+
+    def [](key)
+      @attributes[internalize! key].value
+    end
+
+    def []=(key, value)
+      @attributes[internalize! key] = Attr.new(self, value)
+    end
+
+    def fetch(key, ignored=nil)
+      self[key]
+    end
+
+    def to_hash
+      Hash[to_a]
+    end
+    alias to_h to_hash
+
+    def merge(overrides)
+      self.class.new(to_h.merge overrides)
+    end
+
+    def keys
+      to_a.map(&:first)
+    end
+
+    def values
+      to_a.map(&:last)
+    end
+
+    def inspect
+      classname = self.class.name ? "HashStruct #{self.class.name}" : self.class.inspect
+      inspected_attrs = map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+      "#<#{classname}: {#{inspected_attrs}}>"
+    end
+
+    def pretty_print(pp)
+      pp.text self.class.name || 'HashStruct.anon { ... }'
+      pp.text '.new('
+      pp.group 2 do
+        pp.breakable '' # place inside so that if we break, we are indented
+        last_key = keys.last
+        each do |key, value|
+          # text-space-value, or text-neline-indent-value
+          pp.text "#{key}:"
+          pp.group 2 do
+            pp.breakable " "
+            pp.pp value
+          end
+          # all lines end in a comma, and can have a newline, except the last
+          pp.comma_breakable unless key == last_key
+        end
+      end
+      pp.breakable ''
+      pp.text ')'
+    end
+
+    def key?(key)
+      key.respond_to?(:to_sym) && @attributes.key?(key.to_sym)
+    end
+    alias has_key? key?
+    alias include? key? # b/c Hash does this
+    alias member?  key? # b/c Hash does this
+
+    def ==(other)
+      if equal? other
+        true
+      elsif other.kind_of? Hash
+        to_h == other
+      elsif other.respond_to?(:to_h)
+        to_h == other.to_h
+      else
+        false
+      end
+    end
+    alias eql? ==
+
+    # this might be pretty expensive
+    def hash
+      to_h.hash
+    end
+
+    private
+
+    def internalize!(key)
+      internal = key.to_sym
+      @attributes.key?(internal) || raise(KeyError)
+      internal
+    rescue NoMethodError, KeyError
+      raise KeyError, "#{key.inspect} is not an attribute, should be in #{@attributes.keys.inspect}"
+    end
+  end
+end

data/lib/seeing_is_believing/result.rb

@@ -0,0 +1,89 @@
+class SeeingIsBelieving
+  class Result
+    include Enumerable
+    RecordedException = Struct.new :line_number, :class_name, :message, :backtrace
+
+    attr_accessor :stdout, :stderr, :exitstatus, :max_line_captures, :exceptions, :num_lines, :sib_version, :ruby_version, :filename, :timeout_seconds
+
+    def has_exception?
+      exceptions.any?
+    end
+
+    def initialize
+      self.stdout     = ''
+      self.stderr     = ''
+      self.exceptions = []
+    end
+
+    def has_stdout?
+      stdout && !stdout.empty?
+    end
+
+    def has_stderr?
+      stderr && !stderr.empty?
+    end
+
+    def timeout?
+      !!timeout_seconds
+    end
+
+    def record_result(type, line_number, value)
+      results_for(line_number, type) << value
+      value
+    end
+
+    def record_exception(line_number, exception_class, exception_message, exception_backtrace)
+      self.exceptions << RecordedException.new(line_number, exception_class, exception_message, exception_backtrace)
+    end
+
+    def exception
+      exceptions.first
+    end
+
+    def [](line_number, type=:inspect)
+      results_for(line_number, type)
+    end
+
+    def each(&block)
+      return to_enum :each unless block
+      (1..num_lines).each { |line_number| block.call self[line_number] }
+    end
+
+    def max_line_captures
+      @max_line_captures || Float::INFINITY
+    end
+
+    def as_json
+      # We have both an exception and a list of exceptions because multiple exceptions
+      # weren't added until #85, and I don't want to break backwards compatibility right now.
+      { stdout:     stdout,
+        stderr:     stderr,
+        exitstatus: exitstatus,
+        exception:  exception_json(exception),
+        exceptions: exceptions.map { |e| exception_json e },
+        lines:      each.with_object(Hash.new)
+                        .with_index(1) { |(result, hash), line_number| hash[line_number] = result },
+      }
+    end
+
+    private
+
+    def results_for(line_number, type)
+      line_results = (results[line_number] ||= Hash.new { |h, k| h[k] = [] })
+      line_results[type]
+    end
+
+    def results
+      @results ||= Hash.new
+    end
+
+    def exception_json(exception)
+      return nil unless exception
+      { line_number_in_this_file: exception.line_number,
+        class_name:               exception.class_name,
+        message:                  exception.message,
+        backtrace:                exception.backtrace,
+      }
+    end
+  end
+end

data/lib/seeing_is_believing/safe.rb

@@ -0,0 +1,112 @@
+# 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
+
+    begin
+      refine Kernel do
+        alias inspect inspect
+      end
+    rescue TypeError
+      # Ruby < 2.4 can't refine a module,
+      # so this optimization is only available on >= 2.4
+    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
+    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 Integer 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