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

data/lib/seeing_is_believing.rb

@@ -1,58 +1,69 @@
-require 'stringio'
 require 'tmpdir'
 
 require 'seeing_is_believing/result'
 require 'seeing_is_believing/version'
 require 'seeing_is_believing/debugger'
-require 'seeing_is_believing/inspect_expressions'
+require 'seeing_is_believing/wrap_expressions_with_inspect'
+require 'seeing_is_believing/hash_struct'
 require 'seeing_is_believing/evaluate_by_moving_files'
+require 'seeing_is_believing/event_stream/handlers/debug'
+require 'seeing_is_believing/event_stream/handlers/update_result'
 
 class SeeingIsBelieving
-  BLANK_REGEX = /\A\s*\Z/
+  class Options < HashStruct
+    predicate(:event_handler)     { EventStream::Handlers::UpdateResult.new Result.new }
+    attribute(:filename)          { nil }
+    attribute(:encoding)          { nil }
+    attribute(:stdin)             { "" }
+    attribute(:require_files)     { ['seeing_is_believing/the_matrix'] }
+    attribute(:load_path_dirs)    { [File.expand_path('..', __FILE__)] }
+    attribute(:timeout_seconds)   { 0 }
+    attribute(:debugger)          { Debugger::Null }
+    attribute(:max_line_captures) { Float::INFINITY }
+    attribute(:rewrite_code)      { WrapExpressionsWithInspect }
+  end
 
   def self.call(*args)
     new(*args).call
   end
 
+  attr_reader :options
   def initialize(program, options={})
-    @program            = program
-    @filename           = options[:filename]
-    @stdin              = to_stream options.fetch(:stdin, '')
-    @require            = options.fetch :require, ['seeing_is_believing/the_matrix']
-    @load_path          = options.fetch :load_path, []
-    @encoding           = options.fetch :encoding,  nil
-    @timeout            = options[:timeout]
-    @debugger           = options.fetch :debugger, Debugger.new(stream: nil)
-    @number_of_captures = options.fetch :number_of_captures, Float::INFINITY
-    @evaluator          = options.fetch :evaluator, EvaluateByMovingFiles
-    @record_expressions = options.fetch :record_expressions, InspectExpressions # TODO: rename to wrap_expressions
+    @program = program
+    @program += "\n" unless @program.end_with? "\n"
+    @options = Options.new options
   end
 
   def call
     @memoized_result ||= Dir.mktmpdir("seeing_is_believing_temp_dir") { |dir|
-      filename    = @filename || File.join(dir, 'program.rb')
-      new_program = @record_expressions.call "#{@program.chomp}\n", filename, @number_of_captures
-      @debugger.context("TRANSLATED PROGRAM") { new_program }
-
-      result = @evaluator.call new_program,
-                      filename,
-                      input_stream:       @stdin,
-                      require:            @require,
-                      load_path:          @load_path,
-                      encoding:           @encoding,
-                      timeout:            @timeout,
-                      debugger:           @debugger
-
-      @debugger.context("RESULT") { result.inspect }
-
-      result
+      filename = options.filename || File.join(dir, 'program.rb')
+      new_program = options.rewrite_code.call @program
+
+      options.debugger.context("REWRITTEN PROGRAM") { new_program }
+
+      EvaluateByMovingFiles.call \
+        new_program,
+        filename,
+        event_handler:     debugging_handler,
+        provided_input:    options.stdin,
+        require_files:     options.require_files,
+        load_path_dirs:    options.load_path_dirs,
+        encoding:          options.encoding,
+        timeout_seconds:   options.timeout_seconds,
+        max_line_captures: options.max_line_captures
+
+      options.event_handler
     }
   end
 
   private
 
-  def to_stream(string_or_stream)
-    return string_or_stream if string_or_stream.respond_to? :gets
-    StringIO.new string_or_stream
+  # Even though the debugger can be disabled,
+  # Handlers::Debug is somewhat expensive, and there could be tens of millions of calls
+  # e.g. https://github.com/JoshCheek/seeing_is_believing/issues/12
+  # so just skip it in this case
+  def debugging_handler
+    return options.event_handler unless options.debugger.enabled?
+    EventStream::Handlers::Debug.new options.debugger, options.event_handler
   end
 end

data/lib/seeing_is_believing/binary.rb

@@ -1,125 +1,68 @@
 require 'seeing_is_believing'
-require 'seeing_is_believing/binary/parse_args'
-require 'seeing_is_believing/binary/interpret_flags'
-require 'seeing_is_believing/binary/remove_annotations'
+require 'seeing_is_believing/binary/config'
+require 'seeing_is_believing/binary/engine'
 
 class SeeingIsBelieving
   module Binary
     SUCCESS_STATUS              = 0
-    DISPLAYABLE_ERROR_STATUS    = 1 # e.g. there was an error, but the output is legit (we can display exceptions)
-    NONDISPLAYABLE_ERROR_STATUS = 2 # e.g. an error like incorrect invocation or syntax that can't be displayed in the input program
+    DISPLAYABLE_ERROR_STATUS    = 1 # e.g. user code raises an exception (we can display this in the output)
+    NONDISPLAYABLE_ERROR_STATUS = 2 # e.g. SiB was invoked incorrectly
 
     def self.call(argv, stdin, stdout, stderr)
-      flags   = ParseArgs.call(argv)
-      options = InterpretFlags.new(flags, stdin, stdout)
+      config = Config.new.parse_args(argv).finalize(stdin, stdout, stderr, File)
+      engine = Engine.new config
 
-      if options.errors.any?
-        stderr.puts options.errors.join("\n")
-        return NONDISPLAYABLE_ERROR_STATUS
-      end
-
-      if options.print_help?  # TODO: Should this be first?
-        stdout.puts options.help_screen
+      if config.print_help?
+        stdout.puts config.help_screen
         return SUCCESS_STATUS
       end
 
-      if options.print_version?
+      if config.print_version?
         stdout.puts SeeingIsBelieving::VERSION
         return SUCCESS_STATUS
       end
 
-      if options.provided_filename_dne?
-        stderr.puts "#{options.filename} does not exist!"
+      if config.errors.any?
+        stderr.puts *config.errors, *config.deprecations
         return NONDISPLAYABLE_ERROR_STATUS
       end
 
-      if options.print_cleaned?
-        stdout.print RemoveAnnotations.call(options.prepared_body, true, options.marker_regexes)
+      if config.print_cleaned?
+        stdout.print engine.cleaned_body
         return SUCCESS_STATUS
       end
 
-      syntax_error_notice = syntax_error_notice_for(options.body)
-      if syntax_error_notice
-        stderr.puts syntax_error_notice
-        return NONDISPLAYABLE_ERROR_STATUS
-      end
-
-      results, program_timedout, unexpected_exception =
-        evaluate_program(options.prepared_body, options.lib_options)
-
-      if program_timedout
-        stderr.puts "Timeout Error after #{options.timeout} seconds!"
+      if engine.syntax_error?
+        stderr.puts engine.syntax_error
         return NONDISPLAYABLE_ERROR_STATUS
       end
 
-      if unexpected_exception.kind_of? BugInSib
-        stderr.puts unexpected_exception.message
-        return NONDISPLAYABLE_ERROR_STATUS
-      end
+      engine.evaluate!
 
-      if unexpected_exception
-        stderr.puts unexpected_exception.class,
-                    unexpected_exception.message,
-                    "",
-                    unexpected_exception.backtrace
+      if engine.timed_out?
+        stderr.puts "Timeout Error after #{config.timeout_seconds} seconds!"
         return NONDISPLAYABLE_ERROR_STATUS
       end
 
-      if options.result_as_json?
+      if config.result_as_json?
         require 'json'
-        stdout.puts JSON.dump(result_as_data_structure(results))
+        stdout.puts JSON.dump(engine.result.as_json)
         return SUCCESS_STATUS
+      elsif config.print_event_stream?
+        # no op, the event stream handler has been printing it all along
+      elsif config.debug?
+        config.debugger.context("OUTPUT") { engine.annotated_body }
+      else
+        stdout.print engine.annotated_body
       end
 
-      # TODO: Annoying debugger stuff from annotators can move up to here
-      # or maybe debugging goes to stderr, and we still print this anyway?
-      stdout.print options.annotator.call(options.prepared_body,
-                                          results,
-                                          options.annotator_options)
-
-      if options.inherit_exit_status?
-        results.exitstatus
-      elsif results.has_exception? && results.exitstatus != 0 # e.g. `exit 0` raises SystemExit but isn't an error
-        DISPLAYABLE_ERROR_STATUS
-      else
+      if config.inherit_exitstatus?
+        engine.exitstatus
+      elsif engine.exitstatus.zero?
         SUCCESS_STATUS
+      else
+        DISPLAYABLE_ERROR_STATUS
       end
     end
-
-    private
-
-    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
-      # This is because Ruby will stop reading from stdin if everything left is in the DATA segment, and the data segment is not referenced.
-      # In this case, the Syntax is fine
-      # https://bugs.ruby-lang.org/issues/9583
-    rescue Errno::EPIPE
-      return nil
-    end
-
-    def self.evaluate_program(body, options)
-      return SeeingIsBelieving.call(body, options), nil, nil
-    rescue Timeout::Error
-      return nil, true, nil
-    rescue Exception
-      return nil, false, $!
-    end
-
-    def self.result_as_data_structure(results)
-      exception = results.has_exception? && { line_number_in_this_file: results.exception.line_number,
-                                              class_name:               results.exception.class_name,
-                                              message:                  results.exception.message,
-                                              backtrace:                results.exception.backtrace
-                                            }
-      { stdout:      results.stdout,
-        stderr:      results.stderr,
-        exit_status: results.exitstatus,
-        exception:   exception,
-        lines:       results.each.with_object(Hash.new).with_index(1) { |(result, hash), line_number| hash[line_number] = result },
-      }
-    end
   end
 end

data/lib/seeing_is_believing/binary/align_chunk.rb

@@ -18,19 +18,38 @@ class SeeingIsBelieving
 
       def line_lengths
         @line_lengths ||= begin
-          line_num_to_indexes = CommentableLines.new(body).call # {line_number => [index_in_file, index_in_col]}
-          Hash[line_num_to_indexes
-                 .keys
-                 .sort
-                 .slice_before { |line_number| line_num_to_indexes[line_number].last.zero? }
-                 .map { |slice|
-                   max_chunk_length = 2 + slice.map { |line_num| line_num_to_indexes[line_num].last }.max
-                   slice.map { |line_number| [line_number, max_chunk_length] }
-                 }
-                 .flatten(1)
-          ]
+          # sheesh, I need like Hash#map_values or something
+          line_nums_to_cols = Hash.[] \
+            CommentableLines.call(body)
+                            .map { |line_num, (file_index, col_index)|
+                              [line_num, col_index-amount_of_preceding_whitespace(file_index)]
+                            }
+
+          Hash.[] \
+            line_nums_to_cols
+              .keys
+              .sort
+              .slice_before { |line_number| line_nums_to_cols[line_number].zero?  }
+              .flat_map { |slice|
+                max_chunk_length = 2 + slice.map { |line_num| line_nums_to_cols[line_num] }.max
+                slice.map { |line_number| [line_number, max_chunk_length] }
+              }
+        end
+      end
+
+      def trim_trailing_whitespace(line_nums_to_indexes)
+        line_nums_to_indexes.each do |num, indexes|
+          index_in_file = indexes[0]
+          num_to_trim   = amount_of_preceding_whitespace(index_in_file)
+          indexes.map! { |index| index - num_to_trim }
         end
       end
+
+      def amount_of_preceding_whitespace(index_of_trailing_newline)
+        index = index_of_trailing_newline - 1
+        index -= 1 while 0 <= index && body[index] !~ /[\S\n]/
+        index_of_trailing_newline - index - 1
+      end
     end
   end
 end

data/lib/seeing_is_believing/binary/annotate_end_of_file.rb

@@ -1,32 +1,26 @@
 require 'seeing_is_believing/binary' # defines the markers
-require 'seeing_is_believing/binary/comment_formatter'
+require 'seeing_is_believing/binary/format_comment'
 
 class SeeingIsBelieving
   module Binary
     module AnnotateEndOfFile
       extend self
 
-      # TODO: Switch options to markers
       def add_stdout_stderr_and_exceptions_to(new_body, results, options)
         output = stdout_ouptut_for(results, options)    <<
                  stderr_ouptut_for(results, options)    <<
                  exception_output_for(results, options)
 
-        # this technically could find an __END__ in a string or whatever
-        # going to just ignore that, though
-        if new_body[/^__END__$/]
-          new_body.sub! "\n__END__", "\n#{output}__END__"
-        else
-          new_body << "\n" unless new_body.end_with? "\n"
-          new_body << output
-        end
+        code = Code.new(new_body)
+        code.rewriter.insert_after code.body_range, output
+        new_body.replace code.rewriter.process
       end
 
       def stdout_ouptut_for(results, options)
         return '' unless results.has_stdout?
         output = "\n"
         results.stdout.each_line do |line|
-          output << CommentFormatter.call(0, options[:markers][:stdout], line.chomp, options) << "\n"
+          output << FormatComment.call(0, options[:markers][:stdout][:prefix], line.chomp, options) << "\n"
         end
         output
       end
@@ -35,23 +29,23 @@ class SeeingIsBelieving
         return '' unless results.has_stderr?
         output = "\n"
         results.stderr.each_line do |line|
-          output << CommentFormatter.call(0, options[:markers][:stderr], line.chomp, options) << "\n"
+          output << FormatComment.call(0, options[:markers][:stderr][:prefix], line.chomp, options) << "\n"
         end
         output
       end
 
       def exception_output_for(results, options)
         return '' unless results.has_exception?
-        exception_marker = options[:markers][:exception]
+        exception_marker = options[:markers][:exception][:prefix]
         exception = results.exception
         output = "\n"
-        output << CommentFormatter.new(0, exception_marker, exception.class_name, options).call << "\n"
+        output << FormatComment.new(0, exception_marker, exception.class_name, options).call << "\n"
         exception.message.each_line do |line|
-          output << CommentFormatter.new(0, exception_marker, line.chomp, options).call << "\n"
+          output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
         end
         output << exception_marker.sub(/\s+$/, '') << "\n"
         exception.backtrace.each do |line|
-          output << CommentFormatter.new(0, exception_marker, line.chomp, options).call << "\n"
+          output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
         end
         output
       end

data/lib/seeing_is_believing/binary/annotate_every_line.rb

@@ -1,16 +1,6 @@
 class SeeingIsBelieving
   module Binary
     class AnnotateEveryLine
-      def self.prepare_body(uncleaned_body, marker_regexes)
-        require 'seeing_is_believing/binary/remove_annotations'
-        RemoveAnnotations.call uncleaned_body, true, marker_regexes
-      end
-
-      def self.expression_wrapper(markers, marker_regexes)
-        require 'seeing_is_believing/inspect_expressions'
-        InspectExpressions
-      end
-
       def self.call(body, results, options)
         new(body, results, options).call
       end
@@ -24,7 +14,9 @@ class SeeingIsBelieving
       def call
         @new_body ||= begin
           require 'seeing_is_believing/binary/comment_lines'
-          require 'seeing_is_believing/binary/comment_formatter'
+          require 'seeing_is_believing/binary/format_comment'
+          exception_text = @options[:markers][:exception][:prefix]
+          value_text     = @options[:markers][:value][:prefix]
 
           alignment_strategy = @options[:alignment_strategy].new(@body)
           exception_lineno   = @results.has_exception? ? @results.exception.line_number : -1
@@ -32,10 +24,10 @@ class SeeingIsBelieving
             options = @options.merge pad_to: alignment_strategy.line_length_for(line_number)
             if exception_lineno == line_number
               result = sprintf "%s: %s", @results.exception.class_name, @results.exception.message.gsub("\n", '\n')
-              CommentFormatter.call(line.size, exception_marker, result, options)
+              FormatComment.call(line.size, exception_text, result, options)
             elsif @results[line_number].any?
               result  = @results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
-              CommentFormatter.call(line.size, value_marker, result, options)
+              FormatComment.call(line.size, value_text, result, options)
             else
               ''
             end
@@ -44,21 +36,9 @@ class SeeingIsBelieving
           require 'seeing_is_believing/binary/annotate_end_of_file'
           AnnotateEndOfFile.add_stdout_stderr_and_exceptions_to new_body, @results, @options
 
-          # What's w/ this debugger? maybe this should move higher?
-          @options.fetch(:debugger).context "OUTPUT"
           new_body
         end
       end
-
-      private
-
-      def value_marker
-        @value_marker ||= @options.fetch(:markers).fetch(:value)
-      end
-
-      def exception_marker
-        @xnextline_marker ||= @options.fetch(:markers).fetch(:exception)
-      end
     end
   end
 end

data/lib/seeing_is_believing/binary/annotate_marked_lines.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+require 'seeing_is_believing/code'
+
+
+# *sigh* need to find a way to join the annotators.
+# They are sinful ugly, kinda hard to work with,
+# and absurdly duplicated.
+
+class SeeingIsBelieving
+  module Binary
+    # Based on the behaviour of xmpfilger (a binary in the rcodetools gem)
+    # See https://github.com/JoshCheek/seeing_is_believing/issues/44 for more details
+    class AnnotateMarkedLines
+      def self.code_rewriter(markers)
+        lambda do |program|
+          inspect_linenos = []
+          pp_linenos      = []
+          value_regex     = markers[:value][:regex]
+          Code.new(program).inline_comments.each do |c|
+            next unless c.text[value_regex]
+            c.whitespace_col == 0 ? pp_linenos      << c.line_number - 1
+                                  : inspect_linenos << c.line_number
+          end
+
+          should_inspect = false
+          should_pp      = false
+          WrapExpressions.call \
+            program,
+            before_each: -> line_number {
+              should_inspect = inspect_linenos.include? line_number
+              should_pp      = pp_linenos.include?      line_number
+              should_inspect || should_pp ?  '(' : ''
+            },
+            after_each:  -> line_number {
+              # 74 b/c pretty print_defaults to 79 (guessing 80 chars with 1 reserved for newline), and
+              # 79 - "# => ".length # => 4
+              inspect        = "$SiB.record_result :inspect, #{line_number}, v"
+              pp             = "$SiB.record_result(:pp, #{line_number}, v) { PP.pp v, '', 74 }"
+
+              if    should_inspect && should_pp then ").tap { |v| #{inspect}; #{pp} }"
+              elsif should_inspect              then ").tap { |v| #{inspect} }"
+              elsif should_pp                   then ").tap { |v| #{pp} }"
+              else                                   ""
+              end
+            }
+        end
+      end
+
+      def self.call(body, results, options)
+        new(body, results, options).call
+      end
+
+      def initialize(body, results, options={})
+        @options = options
+        @body    = body
+        @results = results
+      end
+
+      # seems like maybe this should respect the alignment strategy (not what xmpfilter does, but there are other ways I'd like to deviate anyway)
+      # and we should just add a new alignment strategy for default xmpfilter style
+      def call
+        @new_body ||= begin
+          require 'seeing_is_believing/binary/rewrite_comments'
+          require 'seeing_is_believing/binary/format_comment'
+          include_lines = []
+
+          if @results.has_exception?
+            exception_result  = sprintf "%s: %s", @results.exception.class_name, @results.exception.message.gsub("\n", '\n')
+            exception_lineno  = @results.exception.line_number
+            include_lines << exception_lineno
+          end
+
+          new_body = RewriteComments.call @body, include_lines: include_lines do |comment|
+            exception_on_line  = exception_lineno == comment.line_number
+            annotate_this_line = comment.text[value_regex]
+            pp_annotation      = annotate_this_line && comment.whitespace_col.zero?
+            normal_annotation  = annotate_this_line && !pp_annotation
+            if exception_on_line && annotate_this_line
+              [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, exception_result, @options)]
+            elsif exception_on_line
+              whitespace = comment.whitespace
+              whitespace = " " if whitespace.empty?
+              [whitespace, FormatComment.call(0, exception_prefix, exception_result, @options)]
+            elsif normal_annotation
+              result = @results[comment.line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+              [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, result, @options)]
+            elsif pp_annotation
+              result = @results[comment.line_number-1, :pp].map { |result| result.chomp }.join("\n,") # ["1\n2", "1\n2", ...
+              swap_leading_whitespace_in_multiline_comment(result)
+              comment_lines = result.each_line.map.with_index do |comment_line, result_offest|
+                if result_offest == 0
+                  FormatComment.call(comment.whitespace_col, value_prefix, comment_line.chomp, @options)
+                else
+                  leading_whitespace = " " * comment.text_col
+                  leading_whitespace << FormatComment.call(comment.whitespace_col, nextline_prefix, comment_line.chomp, @options)
+                end
+              end
+              comment_lines = [value_prefix.rstrip] if comment_lines.empty?
+              [comment.whitespace, comment_lines.join("\n")]
+            else
+              [comment.whitespace, comment.text]
+            end
+          end
+
+          require 'seeing_is_believing/binary/annotate_end_of_file'
+          AnnotateEndOfFile.add_stdout_stderr_and_exceptions_to new_body, @results, @options
+
+          new_body
+        end
+      end
+
+      def value_prefix
+        @value_prefix ||= @options[:markers][:value][:prefix]
+      end
+
+      def nextline_prefix
+        @nextline_prefix ||= ('#' + ' '*value_prefix.length.pred)
+      end
+
+      def exception_prefix
+        @exception_prefix ||= @options[:markers][:exception][:prefix]
+      end
+
+      def value_regex
+        @value_regex ||= @options[:markers][:value][:regex]
+      end
+
+      def swap_leading_whitespace_in_multiline_comment(comment)
+        return if comment.scan("\n").size < 2
+        return if comment[0] =~ /\S/
+        nonbreaking_space = " "
+        comment[0] = nonbreaking_space
+      end
+    end
+  end
+end