seeing_is_believing 3.0.0.beta.5 → 3.0.0.beta.6

data/lib/seeing_is_believing/binary/remove_annotations.rb

@@ -68,33 +68,31 @@ class SeeingIsBelieving
       def annotation_chunks_in(code)
         code
           .inline_comments
-          .map { |comment| [ (comment.text[value_regex]     ||     # associates each comment to its annotation
-                              comment.text[exception_regex] ||
-                              comment.text[stdout_regex]    ||
-                              comment.text[stderr_regex]
-                             ),
-                             comment]}
-          .slice_before { |annotation, comment| annotation }       # annotations begin chunks
-          .select       { |(annotation, start), *| annotation }    # discard chunks not beginning with an annotation (probably can only happens on first comment)
-          .map { |(annotation, start), *rest|                      # end the chunk if the comment doesn't meet nextline criteria
+          .map { |comment| # associate each annotation to its comment
+            annotation = comment.text[value_regex]     ||
+                         comment.text[exception_regex] ||
+                         comment.text[stdout_regex]    ||
+                         comment.text[stderr_regex]
+            [annotation, comment]
+          }
+          .slice_before { |annotation, comment| annotation }    # annotations begin chunks
+          .select       { |(annotation, start), *| annotation } # discard chunks not beginning with an annotation (probably can only happens on first comment)
+          .map { |(annotation, start), *rest|                   # end the chunk if the comment doesn't meet nextline criteria
             nextline_comments = []
-            prev = start
+            prev              = start
             rest.each { |_, potential_nextline|
-              break unless prev.line_number.next == potential_nextline.line_number &&
-                             start.text_col == potential_nextline.text_col         &&
-                             potential_nextline.whitespace_col.zero?               &&
-                             annotation.length <= potential_nextline.text[/#\s*/].length
-              prev = potential_nextline
+              sequential                   = (prev.line_number.next == potential_nextline.line_number)
+              vertically_aligned           = start.text_col == potential_nextline.text_col
+              only_preceded_by_whitespace  = potential_nextline.whitespace_col.zero?
+              indention_matches_annotation = annotation.length <= potential_nextline.text[/#\s*/].length
+              break unless sequential && vertically_aligned && only_preceded_by_whitespace && indention_matches_annotation
               nextline_comments << potential_nextline
+              prev = potential_nextline
             }
             [start, nextline_comments]
           }
       end
 
-      def value_prefix
-        @value_prefix ||= markers.fetch(:value).fetch(:prefix)
-      end
-
       def value_regex
         @value_regex ||= markers.fetch(:value).fetch(:regex)
       end

data/lib/seeing_is_believing/error.rb

@@ -12,6 +12,6 @@ class SeeingIsBelieving
   end
 
   # EventStream
-  NoMoreEvents = Class.new SeeingIsBelievingError
-  UnknownEvent = Class.new SeeingIsBelievingError
+  NoMoreEvents       = Class.new SeeingIsBelievingError
+  UnknownEvent       = Class.new SeeingIsBelievingError
 end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -33,7 +33,7 @@ class SeeingIsBelieving
       self.encoding          = options.delete(:encoding)
       self.timeout_seconds   = options.delete(:timeout_seconds)    || 0 # 0 is the new infinity
       self.provided_input    = options.delete(:provided_input)     || String.new
-      self.event_handler     = options.delete(:event_handler)      || raise("must provide an event handler")
+      self.event_handler     = options.delete(:event_handler)      || raise(ArgumentError, "must provide an :event_handler")
       self.load_path_flags   = (options.delete(:load_path_dirs)    || []).map { |dir| ['-I', dir] }.flatten
       self.require_flags     = (options.delete(:require_files)     || ['seeing_is_believing/the_matrix']).map { |filename| ['-r', filename] }.flatten
       self.max_line_captures = (options.delete(:max_line_captures) || Float::INFINITY) # (optimization: child stops producing results at this number, even though it might make more sense for the consumer to stop emitting them)
@@ -110,7 +110,8 @@ class SeeingIsBelieving
                child_eventstream => child_eventstream }
       child = Process.detach Kernel.spawn(env, *popen_args, opts)
 
-      # close b/c we won't get EOF until all fds are closed
+      # close child streams b/c they won't emit EOF
+      # until both child and parent references are closed
       child_eventstream.close
       child_stdout.close
       child_stderr.close
@@ -123,8 +124,8 @@ class SeeingIsBelieving
         stdin.close
       }
 
-      # consume events
-      consumer        = EventStream::Consumer.new(events: eventstream, stdout: stdout, stderr: stderr)
+      # set up the event consumer
+      consumer = EventStream::Consumer.new(events: eventstream, stdout: stdout, stderr: stderr)
       consumer_thread = Thread.new { consumer.each { |e| event_handler.call e } }
 
       # wait for completion
@@ -134,8 +135,9 @@ class SeeingIsBelieving
         consumer_thread.join
       end
     rescue Timeout::Error
-      Process.kill "TERM", child.pid
-      raise
+      Process.kill "KILL", child.pid
+      consumer.process_timeout timeout_seconds
+      consumer_thread.join # finish consuming events
     ensure
       [stdin, stdout, stderr, eventstream].each { |io| io.close unless io.closed? }
     end

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -8,32 +8,56 @@ class SeeingIsBelieving
   module EventStream
     class Consumer
       class FinishCriteria
-        CRITERIA = [
-          :event_thread_finished!,
-          :stdout_thread_finished!,
-          :stderr_thread_finished!,
-          :process_exited!,
-        ].freeze.each do |name|
-          define_method name do
-            @unmet_criteria.delete name
-            @satisfied = @unmet_criteria.empty?
-          end
-        end
+        EventThreadFinished  = Module.new
+        StdoutThreadFinished = Module.new
+        StderrThreadFinished = Module.new
+        ProcessExited        = Module.new
+
         def initialize
-          @satisfied      = false
-          @unmet_criteria = CRITERIA.dup
+          @unmet_criteria = [
+            EventThreadFinished,
+            StdoutThreadFinished,
+            StderrThreadFinished,
+            ProcessExited,
+          ]
         end
+
+        # finish criteria are satisfied,
+        # we can stop processing events
         def satisfied?
-          @satisfied
+          @unmet_criteria.empty?
+        end
+
+        def event_thread_finished!
+          @unmet_criteria.delete EventThreadFinished
+        end
+
+        def stdout_thread_finished!
+          @unmet_criteria.delete StdoutThreadFinished
+        end
+
+        def stderr_thread_finished!
+          @unmet_criteria.delete StderrThreadFinished
+        end
+
+        def received_exitstatus!
+          @unmet_criteria.delete ProcessExited
+        end
+
+        def received_timeout!
+          @unmet_criteria.delete ProcessExited
         end
       end
 
       # https://github.com/JoshCheek/seeing_is_believing/issues/46
       def self.fix_encoding(str)
-        str.encode! Encoding::UTF_8
-      rescue EncodingError
-        str = str.force_encoding(Encoding::UTF_8)
-        return str.scrub('�') if str.respond_to? :scrub # b/c it's not implemented on 1.9.3
+        begin
+          str.encode! Encoding::UTF_8
+        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
@@ -44,6 +68,7 @@ class SeeingIsBelieving
       end
 
       def initialize(streams)
+        @finished            = false
         self.finish_criteria = FinishCriteria.new
         self.queue           = Queue.new
         event_stream         = streams.fetch :events
@@ -94,16 +119,23 @@ class SeeingIsBelieving
         yield call 1 until @finished
       end
 
-      # NOTE: Note it's probably a bad plan to call this method
+      # NOTE: Note it's probably a bad plan to call these methods
       # from within the same thread as the consumer, because if it
       # blocks, who will remove items from the queue?
       def process_exitstatus(status)
-        queue << Events::Exitstatus.new(value: status)
         queue << lambda {
-          finish_criteria.process_exited!
+          queue << Events::Exitstatus.new(value: status)
+          finish_criteria.received_exitstatus!
+        }
+      end
+      def process_timeout(seconds)
+        queue << lambda {
+          queue << Events::Timeout.new(seconds: seconds)
+          finish_criteria.received_timeout!
         }
       end
 
+
       private
 
       attr_accessor :queue, :finish_criteria
@@ -115,9 +147,8 @@ class SeeingIsBelieving
           event_for element
         when Proc
           element.call
-          if finish_criteria.satisfied?
+          finish_criteria.satisfied? &&
             queue << Events::Finished.new
-          end
           next_event
         when Events::Finished
           @finished = true
@@ -125,7 +156,7 @@ class SeeingIsBelieving
         when Event
           element
         else
-          p "WAT: #{element.inspect}"
+          raise SeeingIsBelieving::UnknownEvent, "WAT IS THIS?: #{element.inspect}"
         end
       end
 

data/lib/seeing_is_believing/event_stream/events.rb

@@ -92,6 +92,17 @@ class SeeingIsBelieving
         attributes :value
       end
 
+      # The process timed out
+      # note that you will probably not receive an exitstatus
+      # if this occurs. Though it's hypothetically possible...
+      # this is all asynchronous.
+      class Timeout < Event
+        def self.event_name
+          :timeout
+        end
+        attributes :seconds
+      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

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

@@ -0,0 +1,26 @@
+require 'seeing_is_believing/event_stream/events'
+
+class SeeingIsBelieving
+  module EventStream
+    module Handlers
+      class RecordExitEvents
+        attr_reader :exitstatus
+        attr_reader :timeout_seconds
+
+        def initialize(next_observer)
+          @next_observer = next_observer
+        end
+
+        def call(event)
+          case event
+          when Events::Exitstatus
+            @exitstatus = event.value
+          when Events::Timeout
+            @timeout_seconds = event.seconds
+          end
+          @next_observer.call(event)
+        end
+      end
+    end
+  end
+end

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

@@ -13,32 +13,10 @@ class SeeingIsBelieving
         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

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

@@ -24,6 +24,7 @@ class SeeingIsBelieving
           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,

data/lib/seeing_is_believing/result.rb

@@ -3,7 +3,7 @@ class SeeingIsBelieving
     include Enumerable
     RecordedException = Struct.new :line_number, :class_name, :message, :backtrace
 
-    attr_accessor :stdout, :stderr, :exitstatus, :max_line_captures, :exception, :num_lines, :sib_version, :ruby_version, :filename
+    attr_accessor :stdout, :stderr, :exitstatus, :max_line_captures, :exception, :num_lines, :sib_version, :ruby_version, :filename, :timeout_seconds
 
     def initialize
       self.stdout = ''
@@ -20,6 +20,10 @@ class SeeingIsBelieving
       stderr && !stderr.empty?
     end
 
+    def timeout?
+      !!timeout_seconds
+    end
+
     def record_result(type, line_number, value)
       results_for(line_number, type) << value
       value
@@ -38,20 +42,6 @@ class SeeingIsBelieving
       (1..num_lines).each { |line_number| block.call self[line_number] }
     end
 
-    def inspect
-      results
-      variables = instance_variables.map do |name|
-        value = instance_variable_get(name)
-        inspected = if name.to_s == '@results'
-          "{#{value.sort_by(&:first).map { |k, v| "#{k.inspect}=>#{v.inspect}"}.join(",\n            ")}}"
-        else
-          value.inspect
-        end
-        "#{name}=#{inspected}"
-      end
-      "#<SIB::Result #{variables.join "\n  "}>"
-    end
-
     def max_line_captures
       @max_line_captures || Float::INFINITY
     end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.0.0.beta.5'
+  VERSION = '3.0.0.beta.6'
 end

data/seeing_is_believing.gemspec

@@ -19,11 +19,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency             "parser",   ">= 2.2.0.2", "< 3.0"
+  s.add_dependency             "parser",   ">= 2.2.0.3", "< 3.0"
 
+  s.add_development_dependency "what_weve_got_here_is_an_error_to_communicate"
   s.add_development_dependency "haiti",    ">= 0.1", "< 0.3"
   s.add_development_dependency "rake",     "~> 10.0"
-  s.add_development_dependency "rspec",    "~>  3.0"
+  s.add_development_dependency "rspec",    "~>  3.2"
   s.add_development_dependency "cucumber", "~>  1.2"
   s.add_development_dependency "ichannel", "~>  5.1"
 

data/spec/binary/config_spec.rb

@@ -8,9 +8,9 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       config.errors.find do |error|
         case error_assertion
         when Regexp
-          error_assertion =~ error.explanation
+          error_assertion =~ error.to_s
         else
-          error.explanation.include? error_assertion
+          error.to_s.include? error_assertion
         end
       end
     end
@@ -37,6 +37,7 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
     deprecated = deprecated_args.first
     expect(deprecated.args).to eq [flag, *args]
     expect(deprecated.explanation).to be_a_kind_of String
+    expect(deprecated.to_s).to include "Deprecated"
   end
 
   shared_examples 'it requires a positive int argument' do |flags|
@@ -103,11 +104,27 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       assert_same_flat_opts ['-jgh+'], ['-j',  '-g',  '-h+']
     end
 
-    specify 'unknown options set an error' do
-      expect(parse(['--xyz'  ])).to have_error '--xyz is not an option'
-      expect(parse(['-y'     ])).to have_error '-y is not an option'
-      expect(parse(['-y', 'b'])).to have_error '-y is not an option'
-      expect(parse(['-+h'    ])).to have_error '-+ is not an option'
+    describe 'ignore_unknown_flags?' do
+      it 'is false by default' do
+        expect(parse([]).ignore_unknown_flags?).to eq false
+      end
+
+      it 'is set to true when it sees the --ignore-unknown-options flag' do
+        expect(parse(['--ignore-unknown-flags']).ignore_unknown_flags?).to eq true
+      end
+
+      specify 'when false, unknown flags set an error' do
+        expect(parse(['--xyz'  ])).to have_error '--xyz is not a flag'
+        expect(parse(['-y'     ])).to have_error '-y is not a flag'
+        expect(parse(['-y', 'b'])).to have_error '-y is not a flag'
+        expect(parse(['-+h'    ])).to have_error '-+ is not a flag'
+      end
+
+      specify 'when true, unknown flags do not set an error' do
+        expect(parse(['--zomg'])).to have_error /zomg/
+        expect(parse(['--ignore-unknown-flags', '--zomg'])).to_not have_error /zomg/
+        expect(parse(['--zomg', '--ignore-unknown-flags'])).to_not have_error /zomg/
+      end
     end
 
     describe 'filename and lib_options.filename' do
@@ -421,7 +438,7 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
     end
 
-    describe 'remove_value_prefixes?', t:true do
+    describe 'remove_value_prefixes?' do
       it 'defaults to true' do
         expect(parse([]).remove_value_prefixes?).to eq true
       end

data/spec/binary/engine_spec.rb

@@ -36,6 +36,7 @@ class SeeingIsBelieving
           allow_any_instance_of(Code::Syntax).to receive(:line_number).and_return   123
           expect(invalid_engine.syntax_error)
             .to eq SyntaxErrorMessage.new(line_number: 123, filename: "filename.rb", explanation: "ERR!!")
+          expect(invalid_engine.syntax_error.to_s).to include "ERR!!"
         end
       end
 
@@ -50,10 +51,11 @@ class SeeingIsBelieving
       end
 
       context 'before evaluating it raises if asked for' do
-        specify('result')               { assert_must_evaluate :result }
-        specify('exitstatus')            { assert_must_evaluate :exitstatus }
-        specify('timed_out?')            { assert_must_evaluate :timed_out? }
-        specify('annotated_body')        { assert_must_evaluate :annotated_body }
+        specify('result')          { assert_must_evaluate :result }
+        specify('exitstatus')      { assert_must_evaluate :exitstatus }
+        specify('timed_out?')      { assert_must_evaluate :timed_out? }
+        specify('timeout_seconds') { assert_must_evaluate :timeout_seconds }
+        specify('annotated_body')  { assert_must_evaluate :annotated_body }
       end
 
       context 'after evaluating' do
@@ -68,11 +70,16 @@ class SeeingIsBelieving
           expect(engine.exitstatus).to eq 88
         end
 
-        specify 'timed_out? is true if the program raised a Timeout::Error' do
+        specify 'timed_out? is true if a Timeout event was emitted' do
           expect(call('', timeout: 1).evaluate!.timed_out?).to eq false
           expect(call('sleep 1', timeout: 0.01).evaluate!.timed_out?).to eq true
         end
 
+        specify 'timeout_seconds is nil, or the timeout duration' do
+          expect(call('', timeout: 1).evaluate!.timeout_seconds).to eq nil
+          expect(call('sleep 1', timeout: 0.01).evaluate!.timeout_seconds).to eq 0.01
+        end
+
         context 'annotated_body' do
           it 'is the body after being run through the annotator' do
             expect(call("1").evaluate!.annotated_body).to eq "1  # => 1"