seeing_is_believing 3.0.0.beta.3 → 3.0.0.beta.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2e468be6e5df6cd6e01b6c6d000e204adea080f
-  data.tar.gz: 27401d23d03170455703d30a285e8a55726c0192
+  metadata.gz: 088b9ff70b1691264f78741d8a0ac2ae7b1afdff
+  data.tar.gz: e895553cdb771ebee4558794ae674be0420b3777
 SHA512:
-  metadata.gz: 572bad143fd60f08c04b43289143f46ade1121300b6073830107ce183aef58741bd1acd3b1d75544d2af878df4802346e2e1a921b5e60464b7eddfb69498e4f5
-  data.tar.gz: 858d05b38816d4d99768985bf0ad16ebc82dd51309f1e5444ff2ce475e501e038b50e4b017dc1f2c16126e20eaafe32a999f85d835fe7f996b13765238be1135
+  metadata.gz: df2363ea76fdbfbea79b7a224873bd9beb56d2cc97bd81bf650f43adf46c22e7577715c114d2977232b35f8f47aa6d3c528b1e094ac26b2e1933115b2e9aa82a
+  data.tar.gz: d2a0cb8f4959efed7f3bfa5a47c1f7e3ac93c8d2652e4f6911b77d288b0bb02b3b20299ab589de51a4080e317213e70de697b50b04d8c3204095e3b7476902b8

data/.travis.yml

@@ -4,6 +4,7 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.2
+  - 2.2.0
   - ruby-head
   - rbx-2
   - jruby-head

data/features/deprecated-flags.feature

@@ -0,0 +1,12 @@
+Feature: Flags that are deprecated
+
+  Features get added, features get removed.
+  Don't want to blow up just b/c of removal of some feature.
+  As such, these flags will continue to not blow up,
+  even though they won't work anymore
+
+  Scenario: --shebang
+    When I run "seeing_is_believing -e 123 --shebang not/a/thing"
+    Then stderr is empty
+    And stdout is "123  # => 123"
+    And the exit status is 0

data/features/flags.feature

@@ -196,6 +196,7 @@ Feature: Using flags
   Scenario: --clean
     Given the file "uncleaned.rb":
     """
+    # comment # => still a comment
     1 + 1  # => not 2
     2 + 2  # ~> Exception, something
 
@@ -211,6 +212,7 @@ Feature: Using flags
     And the exit status is 0
     And stdout is:
     """
+    # comment # => still a comment
     1 + 1
     2 + 2
 
@@ -412,22 +414,6 @@ Feature: Using flags
     2  # => 2
     """
 
-
-  Scenario: --shebang
-    Given the file "fake_ruby":
-    """
-    #!/usr/bin/env ruby
-    $LOAD_PATH.unshift File.expand_path "{{Haiti.config.proving_grounds_dir}}/../lib", __FILE__
-    require 'seeing_is_believing/event_stream/producer'
-    sib = SeeingIsBelieving::EventStream::Producer.new($stdout)
-    sib.record_result(:inspect, 1, /omg/)
-    sib.finish!
-    """
-    When I run "chmod +x fake_ruby"
-    When I run "seeing_is_believing -e 123 --shebang ./fake_ruby"
-    Then stdout is "123  # => /omg/"
-
-
   Scenario: --json
     Given the file "all_kinds_of_output.rb":
     """

data/features/regression.feature

@@ -414,3 +414,49 @@ Feature:
     And stdout includes "require_relative 'at_exit_exception_indirect1'  # => true"
     And stdout includes "RuntimeError"
     And stdout includes "zomg"
+
+
+  Scenario: Comments with makers elsewhere in them
+    Given the file "comments_with_markers_elsewhere.rb":
+    """
+    # a # => a
+    """
+    When I run "seeing_is_believing comments_with_markers_elsewhere.rb"
+    Then stdout is:
+    """
+    # a # => a
+    """
+
+
+  Scenario: Deadlocked
+    Given the file "deadlocked.rb":
+    """
+    require 'thread'
+    Thread.new { Queue.new.shift }.join
+    """
+    When I run "seeing_is_believing deadlocked.rb"
+    Then stdout includes:
+    """
+    require 'thread'                     # => false
+    Thread.new { Queue.new.shift }.join  # ~> fatal
+    """
+
+  @wip
+  Scenario: Xmpfilter does not write the error messages inside of strings
+    Given the file "error_within_string.rb":
+    """
+    raise(ArgumentError, "line1
+          line2")
+    """
+    When I run "seeing_is_believing --xmpfilter-style error_within_string.rb"
+    Then stdout is:
+    """
+    raise(ArgumentError, "line1
+          line2")                # ~> ArgumentError: line1\n      line2
+
+    # ~> ArgumentError
+    # ~> line1
+    # ~>       line2
+    # ~>
+    # ~> f4.rb:1:in `<main>'
+    """

data/features/xmpfilter-style.feature

@@ -152,6 +152,7 @@ Feature: Xmpfilter style
   Scenario: Cleaning previous output
     Given the file "xmpfilter_cleaning.rb":
     """
+    # commented out # => previous annotation
     1 # => "1...
     # => "1111111111...
     #    "1111111111...
@@ -161,6 +162,60 @@ Feature: Xmpfilter style
     When I run "seeing_is_believing --xmpfilter-style --clean xmpfilter_cleaning.rb"
     Then stdout is:
     """
+    # commented out # => previous annotation
     1
     # normal comment
     """
+
+
+  @wip
+  Scenario: Correctly cleans/rewrites when the First line of inspection is indented more than its children
+    Given the file "indented_inspection.rb":
+    """
+    obj = Object.new
+    def obj.inspect
+      " 1 \n2 2\n"
+    end
+    obj
+    # =>
+    """
+    When I run "seeing_is_believing -x indented_inspection.rb | seeing_is_believing -x"
+    Then stdout is:
+    """
+    obj = Object.new
+    def obj.inspect
+      " 1 \n2 2\n"
+    end
+    obj
+    # =>  1
+    #    2 2
+    """
+
+  # this one needs a bit more thought put into it, but I'm kinda fading now
+  @wip
+  Scenario: Error raised on an annotated line does not wipe it out
+    Given the file "error_on_annotated_line.rb":
+    """
+    a # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style error_on_annotated_line.rb"
+    Then I stdout is:
+    """
+    idk, but we need to be able to fix the thing and run it again
+    without losing the annotation
+    """
+
+
+  @not-implemented
+  Scenario: It can record values even when method is overridden
+    Given the file "pretty_inspect_with_method_overridden.rb":
+    """
+    def method()end; self # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style pretty_inspect_with_method_overridden.rb"
+    Then stdout is:
+    """
+    def method()end; self # => main
+    # => main
+    """

data/lib/seeing_is_believing/binary/interpret_flags.rb

@@ -8,7 +8,6 @@ require 'seeing_is_believing/binary/align_chunk'
 
 # Evaluator decision happens here
 require 'seeing_is_believing/evaluate_by_moving_files'
-require 'seeing_is_believing/evaluate_with_eval_in'
 
 # Annotator decision happens here
 require 'seeing_is_believing/binary/annotate_every_line'
@@ -45,7 +44,6 @@ class SeeingIsBelieving
       attr_attribute :markers
       attr_attribute :marker_regexes
       attr_attribute :timeout
-      attr_attribute :shebang
       attr_attribute :filename
       attr_attribute :body
       attr_attribute :annotator_options
@@ -60,7 +58,6 @@ class SeeingIsBelieving
         attributes[:markers]        = flags.fetch(:markers) # TODO: Should probably object-ify these
         attributes[:marker_regexes] = flags.fetch(:marker_regexes).each_with_object({}) { |(k, v), rs| rs[k] = self.class.to_regex v }
         attributes[:timeout]        = flags.fetch(:timeout) # b/c binary prints this out in the error message  TODO: rename seconds_until_timeout
-        attributes[:shebang]        = flags.fetch(:shebang) # b/c binary uses this to validate syntax atm
         attributes[:filename]       = flags.fetch(:filename)
 
         # All predicates
@@ -88,9 +85,8 @@ class SeeingIsBelieving
 
         # The lib's options (passed to SeeingIsBelieving.new)
         attributes[:lib_options] = {
-          evaluate_with:      (flags.fetch(:safe) ? EvaluateWithEvalIn : EvaluateByMovingFiles),
+          evaluate_with:      EvaluateByMovingFiles,
           filename:           (flags.fetch(:as) || filename),
-          ruby_executable:    shebang,
           stdin:              (file_is_on_stdin? ? '' : stdin),
           require:            (['seeing_is_believing/the_matrix'] + flags.fetch(:require)), # TODO: rename requires: files_to_require, or :requires or maybe :to_require
           load_path:          ([File.expand_path('../../..', __FILE__)] + flags.fetch(:load_path)),

data/lib/seeing_is_believing/binary/parse_args.rb

@@ -15,10 +15,10 @@ class SeeingIsBelieving
 
       # TODO: rename to default_marker_regexes ...or turn into fkn objects
       def self.marker_regexes
-        { value:     '#\s*=>\s*',
-          exception: '#\s*~>\s*',
-          stdout:    '#\s*>>\s*',
-          stderr:    '#\s*!>\s*',
+        { value:     '^#\s*=>\s*',
+          exception: '^#\s*~>\s*',
+          stdout:    '^#\s*>>\s*',
+          stderr:    '^#\s*!>\s*',
         }
       end
 
@@ -47,14 +47,14 @@ class SeeingIsBelieving
             when '-D',  '--result-length'       then extract_positive_int_for :max_result_length,  arg
             when '-n',  '--number-of-captures'  then extract_positive_int_for :number_of_captures, arg
             when '-t',  '--timeout'             then extract_non_negative_float_for :timeout,      arg
-            when '-r',  '--require'             then next_arg("#{arg} expected a filename as the following argument but did not see one")       { |filename|   flags[:require]           << filename }
-            when '-I',  '--load-path'           then next_arg("#{arg} expected a directory as the following argument but did not see one")      { |dir|        flags[:load_path]         << dir }
-            when '-e',  '--program'             then next_arg("#{arg} expected a program as the following argument but did not see one")        { |program|    flags[:program_from_args] =  program }
-            when '-a',  '--as'                  then next_arg("#{arg} expected a filename as the following argument but did not see one")       { |filename|   flags[:as]                =  filename }
-            when        '--shebang'             then next_arg("#{arg} expects a ruby executable as the following argument but did not see one") { |executable| flags[:shebang]           =  executable }
+            when '-r',  '--require'             then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename|   flags[:require]           << filename }
+            when '-I',  '--load-path'           then next_arg("#{arg} expected a directory as the following argument but did not see one") { |dir|        flags[:load_path]         << dir }
+            when '-e',  '--program'             then next_arg("#{arg} expected a program as the following argument but did not see one")   { |program|    flags[:program_from_args] =  program }
+            when '-a',  '--as'                  then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename|   flags[:as]                =  filename }
             when '-s',  '--alignment-strategy'  then flags[:alignment_strategy] = args.shift
             when /\A-K(.+)/                     then flags[:encoding] = $1
             when '-K', '--encoding'             then next_arg("#{arg} expects an encoding, see `man ruby` for possibile values") { |encoding| flags[:encoding] = encoding }
+            when        '--shebang'             then next_arg("#{arg} is deprecated, SiB now uses the Ruby it was invoked with")           { |executable| flags[:deprecated_flags] << '--shebang' << executable }
             when /^(-.|--.*)$/                  then flags[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
             when /^-[^-]/                       then args.unshift *normalize_shortflags(arg)
             else
@@ -93,13 +93,13 @@ class SeeingIsBelieving
           require:             ['seeing_is_believing/the_matrix'],
           load_path:           [],
           alignment_strategy:  'chunk',
-          shebang:             'ruby',
           result_as_json:      false,
           markers:             self.class.default_markers,
           marker_regexes:      self.class.marker_regexes,
           short_help_screen:   self.class.help_screen(false),
           long_help_screen:    self.class.help_screen(true),
           safe:                false,
+          deprecated_flags:    [],
         }
       end
 
@@ -166,10 +166,10 @@ Usage: seeing_is_believing [options] [filename]
   -K,  --encoding encoding       # sets file encoding, equivalent to Ruby's -Kx (see `man ruby` for valid values)
   -a,  --as filename             # run the program as if it was the specified filename
   -c,  --clean                   # remove annotations from previous runs of seeing_is_believing
-  -g,  --debug                   # print debugging information (useful if program is fucking up, or if you want to brag)
+  -g,  --debug                   # print debugging information (useful if program is fucking up, or to better understand what SiB does)
   -x,  --xmpfilter-style         # annotate marked lines instead of every line
   -j,  --json                    # print results in json format (i.e. so another program can consume them)
-  -i,  --inherit-exit-status     # exit with the exit status of the program being eval
+  -i,  --inherit-exit-status     # exit with the exit status of the program being evaluated
        --shebang ruby-executable # if you want SiB to use some ruby other than the one in the path
   -v,  --version                 # print the version (#{VERSION})
   -h,  --help                    # help screen without examples

data/lib/seeing_is_believing/binary/remove_annotations.rb

@@ -73,7 +73,7 @@ class SeeingIsBelieving
                               comment.text[stderr_regex]
                              ),
                              comment]}
-          .slice_before { |annotation, comment| annotation }       # annotatios begin chunks
+          .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 = []

data/lib/seeing_is_believing/binary.rb

@@ -38,7 +38,7 @@ class SeeingIsBelieving
         return SUCCESS_STATUS
       end
 
-      syntax_error_notice = syntax_error_notice_for(options.body, options.shebang)
+      syntax_error_notice = syntax_error_notice_for(options.body)
       if syntax_error_notice
         stderr.puts syntax_error_notice
         return NONDISPLAYABLE_ERROR_STATUS
@@ -88,8 +88,8 @@ class SeeingIsBelieving
 
     private
 
-    def self.syntax_error_notice_for(body, shebang)
-      out, err, syntax_status = Open3.capture3 shebang, '-c', stdin_data: body
+    def self.syntax_error_notice_for(body)
+      out, err, syntax_status = Open3.capture3 RbConfig.ruby, '-c', stdin_data: body
       return err unless syntax_status.success?
 
       # The stdin_data may still be getting written when the pipe closes

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -24,11 +24,51 @@ require 'seeing_is_believing/event_stream/update_result'
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
+
+    # *sigh* have to do this b/c can't use Open3, b/c keywords don't work right when the keys are not symbols, and I'm passing a file descriptor
+    # https://github.com/ruby/ruby/pull/808    my pr
+    # https://bugs.ruby-lang.org/issues/10699  they opened an issue
+    # https://bugs.ruby-lang.org/issues/10118  weird feature vs bug conversation
+    module Spawn
+      extend self
+      def popen(*cmd)
+        opts = {}
+        opts = cmd.pop if cmd.last.kind_of? Hash
+
+        in_r, in_w = IO.pipe
+        opts[:in] = in_r
+        in_w.sync = true
+
+        out_r, out_w = IO.pipe
+        opts[:out] = out_w
+
+        err_r, err_w = IO.pipe
+        opts[:err] = err_w
+
+        pid       = spawn(*cmd, opts)
+        wait_thr  = Process.detach(pid)
+
+        in_r.close
+        out_w.close
+        err_w.close
+
+        begin
+          yield in_w, out_r, err_r, wait_thr
+          in_w.close unless in_w.closed?
+          wait_thr.value
+        ensure
+          [in_w, out_r, err_r].each { |io| io.close unless io.closed? }
+          wait_thr.join
+        end
+      end
+    end
+
+
     def self.call(*args)
       new(*args).call
     end
 
-    attr_accessor :program, :filename, :input_stream, :require_flags, :load_path_flags, :encoding, :timeout, :ruby_executable, :debugger, :result
+    attr_accessor :program, :filename, :input_stream, :require_flags, :load_path_flags, :encoding, :timeout, :debugger, :result
 
     def initialize(program, filename, options={})
       self.program         = program
@@ -38,7 +78,6 @@ class SeeingIsBelieving
       self.load_path_flags = options.fetch(:load_path, []).map { |dir| ['-I', dir] }.flatten
       self.encoding        = options.fetch :encoding, nil
       self.timeout         = options[:timeout]
-      self.ruby_executable = options.fetch :ruby_executable, 'ruby'
       self.debugger        = options.fetch :debugger, Debugger.new(stream: nil)
     end
 
@@ -96,7 +135,15 @@ class SeeingIsBelieving
     end
 
     def evaluate_file
-      Open3.popen3 ENV, *popen_args do |process_stdin, process_stdout, process_stderr, thread|
+      # the event stream
+      es_read, es_write = IO.pipe
+      es_fd = es_write.to_i.to_s
+
+      # invoke the process
+      Spawn.popen ENV, *popen_args, es_fd, es_write => es_write do |process_stdin, process_stdout, process_stderr, thread|
+        # child writes here, we close b/c won't get EOF until all fds are closed
+        es_write.close
+
         # send stdin
         Thread.new {
           input_stream.each_char { |char| process_stdin.write char }
@@ -106,28 +153,30 @@ class SeeingIsBelieving
         # consume events
         self.result = Result.new # set on self b/c if an error is raised, we still want to keep what we recorded
         event_consumer = Thread.new do
-          EventStream::Consumer.new(process_stdout)
-                               .each { |event| EventStream::UpdateResult.call result, event }
+          EventStream::Consumer
+            .new(events: es_read, stdout: process_stdout, stderr: process_stderr)
+            .each { |event| EventStream::UpdateResult.call result, event }
         end
 
-        # process stderr
-        err_reader = Thread.new { process_stderr.read }
-
         begin
           Timeout::timeout timeout do
-            self.stderr     = err_reader.value
-            self.exitstatus = thread.value
             event_consumer.join
+            # TODO: seems like these belong entirely on result, not as ivars of this class
+            self.exitstatus = thread.value
+            self.stderr     = result.stderr
           end
         rescue Timeout::Error
           Process.kill "TERM", thread.pid
           raise $!
         end
       end
+    ensure
+      es_read.close  unless es_read.closed?
+      es_write.close unless es_write.closed?
     end
 
     def popen_args
-      [ruby_executable,
+      [RbConfig.ruby,
          '-W0',                                     # no warnings (b/c I hijack STDOUT/STDERR)
          *(encoding ? ["-K#{encoding}"] : []),      # allow the encoding to be set
          '-I', File.expand_path('../..', __FILE__), # add lib to the load path

data/lib/seeing_is_believing/event_stream/consumer.rb

@@ -1,49 +1,74 @@
 require 'seeing_is_believing/event_stream/events'
 require 'seeing_is_believing/error'
+require 'thread'
+
 class SeeingIsBelieving
   module EventStream
     class Consumer
       NoMoreInput        = Class.new SeeingIsBelievingError
       WtfWhoClosedMyShit = Class.new SeeingIsBelievingError
+      UnknownEvent       = Class.new SeeingIsBelievingError
+
+      def initialize(streams)
+        self.finished_threads = []
+        self.queue            = Queue.new
+        self.event_stream     = streams.fetch :events
+        stdout_stream         = streams.fetch :stdout
+        stderr_stream         = streams.fetch :stderr
+
+        self.stdout_thread = Thread.new do
+          stdout_stream.each_line { |line| queue << Events::Stdout.new(line) }
+          queue << :stdout_thread_finished
+        end
+
+        self.stderr_thread = Thread.new do
+          stderr_stream.each_line { |line| queue << Events::Stderr.new(line) }
+          queue << :stderr_thread_finished
+        end
 
-      def initialize(readstream)
-        @readstream = readstream
+        self.event_thread = Thread.new do
+          begin loop do
+                   break unless line = event_stream.gets
+                   event = event_for line
+                   queue << event
+                 end
+          rescue IOError; queue << WtfWhoClosedMyShit.new("Our end of the pipe was closed!")
+          rescue SeeingIsBelievingError; queue << $!
+          ensure queue << :event_thread_finished
+          end
+        end
       end
 
       def call(n=1)
-        events = n.times.map do
-          raise NoMoreInput if finished?
-          line = @readstream.gets
-          raise NoMoreInput if line.nil?
-          event = event_for line
-          @finished = true if Events::Finish === event
-          event
-        end
-        n == 1 ? events.first : events
-      rescue IOError
-        @finished = true
-        raise WtfWhoClosedMyShit, "Our end of the pipe was closed!"
-      rescue NoMoreInput
-        @finished = true
-        raise
+        return next_event if n == 1
+        Array.new(n) { next_event }
       end
 
       def each
         return to_enum :each unless block_given?
-        loop do
-          event = call
-          yield event unless Events::Finish === event
-        end
+        loop { yield call(1) }
       rescue NoMoreInput
-        return nil
-      end
-
-      def finished?
-        @finished
       end
 
       private
 
+      attr_accessor :queue, :event_stream, :finished_threads
+      attr_accessor :event_thread, :stdout_thread, :stderr_thread
+
+      def next_event
+        raise NoMoreInput if @no_more_input
+
+        case event = queue.shift
+        when Symbol
+          @no_more_input = true if finished_threads.push(event).size == 3
+          next_event
+        when SeeingIsBelievingError
+          raise event
+        else
+          event
+        end
+      end
+
       def extract_token(line)
         event_name = line[/[^ ]+/]
         line.sub! /^\s*[^ ]+\s*/, ''
@@ -59,8 +84,8 @@ class SeeingIsBelieving
         line.split(' ')
       end
 
-      def event_for(line)
-        line.chomp!
+      def event_for(original_line)
+        line       = original_line.chomp
         event_name = extract_token(line).intern
         case event_name
         when :result
@@ -75,7 +100,7 @@ class SeeingIsBelieving
         when :exception
           Events::Exception.new(-1, '', '', []).tap do |exception|
             loop do
-              line = @readstream.gets.chomp
+              line = event_stream.gets.chomp
               case extract_token(line).intern
               when :line_number   then exception.line_number = extract_token(line).to_i
               when :class_name    then exception.class_name  = extract_string(line)
@@ -85,23 +110,22 @@ class SeeingIsBelieving
               end
             end
           end
-        when :stdout
-          Events::Stdout.new(extract_string line)
-        when :stderr
-          Events::Stderr.new(extract_string line)
         when :max_line_captures
           token = extract_token(line)
           value = token =~ /infinity/i ? Float::INFINITY : token.to_i
           Events::MaxLineCaptures.new(value)
         when :exitstatus
-          # TODO: Will this fuck it up if you run `exit true`?
           Events::Exitstatus.new(extract_token(line).to_i)
-        when :finish
-          Events::Finish.new
         when :num_lines
           Events::NumLines.new(extract_token(line).to_i)
+        when :sib_version
+          Events::SiBVersion.new(extract_string line)
+        when :ruby_version
+          Events::RubyVersion.new(extract_string line)
+        when :filename
+          Events::Filename.new(extract_string line)
         else
-          raise "IDK what #{event_name.inspect} is!"
+          raise UnknownEvent, original_line.inspect
         end
       end
     end