seeing_is_believing 3.0.0.beta.4 → 3.0.0.beta.5

data/lib/seeing_is_believing/event_stream/events.rb

@@ -1,17 +1,175 @@
+require 'seeing_is_believing/hash_struct'
+
 class SeeingIsBelieving
   module EventStream
+    Event = HashStruct.anon do # one superclass to rule them all!
+      def self.event_name
+        raise NotImplementedError, "Subclass should have defined this!"
+      end
+
+      def event_name
+        self.class.event_name
+      end
+
+      def as_json
+        [event_name, to_h]
+      end
+    end
+
     module Events
-      LineResult       = Struct.new(:type, :line_number, :inspected)
-      UnrecordedResult = Struct.new(:type, :line_number)
-      Stdout           = Struct.new(:value)
-      Stderr           = Struct.new(:value)
-      MaxLineCaptures  = Struct.new(:value)
-      Filename         = Struct.new(:value)
-      NumLines         = Struct.new(:value)
-      SiBVersion       = Struct.new(:value)
-      RubyVersion      = Struct.new(:value)
-      Exitstatus       = Struct.new(:value)
-      Exception        = Struct.new(:line_number, :class_name, :message, :backtrace)
+      # A line was printed to stdout.
+      class Stdout < Event
+        def self.event_name
+          :stdout
+        end
+        attributes :value
+      end
+
+      # A line was printed to stderr.
+      class Stderr < Event
+        def self.event_name
+          :stderr
+        end
+        attributes :value
+      end
+
+      # The program will not record more results than this for a line.
+      # Note that if this is hit, it will emit an unrecorded_result.
+      class MaxLineCaptures < Event
+        def self.event_name
+          :max_line_captures
+        end
+        def as_json
+          value, is_infinity = if self.value == Float::INFINITY
+                                 [-1, true]
+                               else
+                                 [self.value, false]
+                               end
+          [event_name, {value: value, is_infinity: is_infinity}]
+        end
+        attribute :value
+      end
+
+      # Name of the file being evaluated.
+      class Filename < Event
+        def self.event_name
+          :filename
+        end
+        attributes :value
+      end
+
+      # Number of lines in the program.
+      class NumLines < Event
+        def self.event_name
+          :num_lines
+        end
+        attributes :value
+      end
+
+      # Version of SeeingIsBelieving used to evaluate the code.
+      # Equivalent to `SeeingIsBelieving::VERSION`, and `seeing_is_believing --version`
+      class SiBVersion < Event
+        def self.event_name
+          :sib_version
+        end
+        attributes :value
+      end
+
+      # Version of Ruby being used to evaluate the code.
+      # Equivalent to `RUBY_VERSION`
+      class RubyVersion < Event
+        def self.event_name
+          :ruby_version
+        end
+        attributes :value
+      end
+
+      # The process' exitstatus.
+      class Exitstatus < Event
+        def self.event_name
+          :exitstatus
+        end
+        attributes :value
+      end
+
+      # Emitted when the process invokes exec.
+      # Note that this could be a child process,
+      # so it does not necessarily mean there won't be any more line results
+      class Exec < Event
+        def self.event_name
+          :exec
+        end
+        attributes :args
+      end
+
+      # A line was executed, and its result recorded.
+      # Currently, type will either be :inspect, or :pp
+      # :pp is used by AnnotateMarkedLines to facilitate xmpfilter style.
+      # If you're consuming the event stream, it's safe to assume type will always be :inspect
+      # If you're using the library, it's whatever you've recorded it as (if you haven't changed this, it's :inspect)
+      class LineResult < Event
+        def self.event_name
+          :line_result
+        end
+        attributes :type, :line_number, :inspected
+      end
+
+      # There were more results than we are emitting for this line / type of recording
+      # See LineResult for explanation of types
+      # This would occur because the line was executed more times than the max.
+      class ResultsTruncated < Event
+        def self.event_name
+          :results_truncated
+        end
+        attributes :type, :line_number
+      end
+
+      # The program raised an exception and did not catch it.
+      # Note that currently `ExitStatus` exceptions are not emitted.
+      # That could change at some point as it seems like the stream consumer
+      # should decide whether they care about that rather than the producer.
+      class Exception < Event
+        def self.event_name
+          :exception
+        end
+        attributes :line_number, :class_name, :message, :backtrace
+      end
+
+      # The process's stdout stream was closed, there will be no more Stdout events.
+      # "side" will either be :producer or :consumer
+      class StdoutClosed < Event
+        def self.event_name
+          :stdout_closed
+        end
+        attributes :side
+      end
+
+      # The process's stderr stream was closed, there will be no more Stderr events.
+      # "side" will either be :producer or :consumer
+      class StderrClosed < Event
+        def self.event_name
+          :stderr_closed
+        end
+        attributes :side
+      end
+
+      # The process's event stream was closed, there will be no more events that come via the stream.
+      # Currently, that's all events except Stdout, StdoutClosed, Stderr, StdoutClosed, ExitStatus, and Finished
+      class EventStreamClosed < Event
+        def self.event_name
+          :event_stream_closed
+        end
+        attributes :side
+      end
+
+      # All streams are closed and the exit status is known.
+      # There will be no more events.
+      class Finished < Event
+        def self.event_name
+          :finished
+        end
+        attributes []
+      end
     end
   end
 end

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

@@ -0,0 +1,57 @@
+class SeeingIsBelieving
+  module EventStream
+    module Handlers
+      class Debug
+        def initialize(debugger, handler)
+          @debugger   = debugger
+          @handler    = handler
+          @seen       = ""
+          @line_width = 150 # debugger is basically for me, so giving it a nice wide width
+          @name_width = 20
+          @attr_width = @line_width - @name_width
+        end
+
+        def call(event)
+          observe event
+          finish if event.kind_of? Events::Finished
+          @handler.call event
+        end
+
+        private
+
+        attr_reader :debugger, :handler
+
+        def finish
+          @debugger.context("EVENTS:") { @seen }
+        end
+
+        def observe(event)
+          name  = event.class.name.split("::").last
+          lines = event.to_h
+                       .map { |attribute, value|
+                          case attribute
+                          when :side      then "#{attribute}: #{value}"
+                          when :value     then value.to_s.chomp
+                          when :backtrace then indented = value.map { |v| "- #{v}" }
+                                               ["backtrace:", *indented]
+                          else "#{attribute}: #{value.inspect}"
+                          end
+                       }
+                       .flatten
+          joined = lines.join ", "
+          if joined.size < @attr_width
+            @seen << sprintf("%-#{@name_width}s%s\n", name, joined)
+          elsif lines.size == 1
+            @seen << sprintf("%-#{@name_width}s%s...\n", name, lines.first[0...@attr_width-3])
+          else
+            @seen << "#{name}\n"
+            lines.each { |line|
+              line = line[0...@line_width-5] << "..." if @line_width < line.length + 2
+              @seen << sprintf("| %s\n", line)
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+class SeeingIsBelieving
+  module EventStream
+    module Handlers
+      class RecordExitStatus
+        attr_reader :exitstatus
+
+        def initialize(next_observer)
+          @next_observer = next_observer
+        end
+
+        def call(event)
+          @exitstatus = event.value if event.event_name == :exitstatus
+          @next_observer.call(event)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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)
+          write_event    event
+          record_outcome event
+        end
+
+        def has_exception?
+          true
+        end
+
+        def exitstatus
+          @exitstatus
+        end
+
+        private
+
+        def write_event(event)
+          @stream << JSON.dump(event.as_json)
+          @stream << "\n"
+          @stream.flush if @flush
+        end
+
+        def record_outcome(event)
+          case event
+          when Events::Exception  then @has_exception = true
+          when Events::Exitstatus then @exitstatus = event.value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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 Exec,
+               Finished,
+               StdoutClosed,
+               StderrClosed,
+               EventStreamClosed
+               # no op
+          else raise "Unknown event: #{event.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -11,13 +11,11 @@ class SeeingIsBelieving
         def shift() end
       end
 
-      attr_accessor :exitstatus, :max_line_captures, :num_lines, :filename
+      attr_accessor :max_line_captures, :filename
 
       def initialize(resultstream)
         self.filename          = nil
-        self.exitstatus        = 0
         self.max_line_captures = Float::INFINITY
-        self.num_lines         = 0
         self.recorded_results  = []
         self.queue             = Queue.new
         self.producer_thread   = Thread.new do
@@ -31,9 +29,9 @@ class SeeingIsBelieving
           rescue IOError, Errno::EPIPE
             queue.clear
           ensure
+            self.queue = NullQueue
             resultstream.flush rescue nil
           end
-          self.queue = NullQueue
         end
       end
 
@@ -56,7 +54,6 @@ class SeeingIsBelieving
       StackErrors = [SystemStackError]
       StackErrors << Java::JavaLang::StackOverflowError if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java'
       def record_result(type, line_number, value)
-        self.num_lines = line_number if num_lines < line_number
         counts = recorded_results[line_number] ||= Hash.new(0)
         count  = counts[type]
         recorded_results[line_number][type] = count.next
@@ -83,25 +80,24 @@ class SeeingIsBelieving
         value
       end
 
+      # records the exception, returns the exitstatus for that exception
       def record_exception(line_number, exception)
-        self.exitstatus = (exception.kind_of?(SystemExit) ? exception.status : 1)
-        if line_number
-          self.num_lines = line_number if num_lines < line_number
-        elsif filename
-          begin
-            line_number = exception.backtrace.grep(/#{filename}/).first[/:\d+/][1..-1].to_i
-          rescue Exception
+        return exception.status if exception.kind_of? SystemExit
+        if !line_number && filename
+          begin line_number = exception.backtrace.grep(/#{filename}/).first[/:\d+/][1..-1].to_i
+          rescue NoMethodError
           end
         end
         line_number ||= -1
-        queue << "exception"
-        queue << "  line_number #{line_number}"
-        queue << "  class_name  #{to_string_token exception.class.name}"
-        queue << "  message     #{to_string_token exception.message}"
-        exception.backtrace.each { |line|
-          queue << "  backtrace   #{to_string_token line}"
-        }
-        queue << "end"
+        queue << [
+          "exception",
+          line_number,
+          to_string_token(exception.class.name),
+          to_string_token(exception.message),
+          exception.backtrace.size,
+          *exception.backtrace.map { |line| to_string_token line }
+        ].join(" ")
+        1 # exit status
       end
 
       def record_filename(filename)
@@ -109,11 +105,16 @@ class SeeingIsBelieving
         queue << "filename #{to_string_token filename}"
       end
 
-      # note that producer will continue reading until stream is closed
-      def finish!
+      def record_exec(args)
+        queue << "exec #{to_string_token args.inspect}"
+      end
+
+      def record_num_lines(num_lines)
         queue << "num_lines #{num_lines}"
-        queue << "exitstatus #{exitstatus}"
-        queue << :break
+      end
+
+      def finish!
+        queue << :break # note that consumer will continue reading until stream is closed
         producer_thread.join
       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