seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/features/regression.feature

@@ -65,7 +65,7 @@ Feature:
       if true     # => true
         return 1  # => 1
       end
-    end
+    end           # => {{method_result :m}}
     m             # => 1
     """
 
@@ -153,6 +153,7 @@ Feature:
     'ç'  # => "ç"
     """
 
+
   Scenario: Some strings look like comments
     Given the file "strings_that_look_like_comments.rb":
     """
@@ -166,6 +167,7 @@ Feature:
      #{2}"  # => "1\n 2"
     """
 
+
   Scenario: Kori's bug (Issue #11)
     Given the file "koris_bug.rb":
     """
@@ -194,6 +196,7 @@ Feature:
     # ~> koris_bug.rb:5:in `<main>'
     """
 
+
   Scenario: lambda-style fibonacci generator
     Given the file "lambda_style_fib_gen.rb":
     """
@@ -220,7 +223,7 @@ Feature:
     class Proc
       def inspect
         "<PROC>"   # => "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>"
-      end
+      end          # => {{method_result :inspect}}
     end
 
     generic_fib_gen = -> current, prev {
@@ -235,6 +238,7 @@ Feature:
     n, fib_gen = fib_gen.()               # => [1, <PROC>]
     """
 
+
   Scenario: Repeated invocations
     When I run "echo 'puts 1' | seeing_is_believing | seeing_is_believing"
     Then stdout is:
@@ -244,6 +248,7 @@ Feature:
     # >> 1
     """
 
+
   Scenario: Heredoc at the end test
     Given the file "heredoc_at_the_end.rb":
     """
@@ -261,6 +266,7 @@ Feature:
     # >> omg
     """
 
+
   Scenario: Long DATA segment in a valid file
     Given the file "long_valid_data_segment.rb":
     """
@@ -288,6 +294,7 @@ Feature:
     And the exit status is 2
     And stdout is empty
 
+
   Scenario: A program using system
     Given the file "invoking_system.rb":
     """
@@ -307,6 +314,7 @@ Feature:
     # !> world
     """
 
+
   Scenario: A program overriding stdout/stderr
     Given the file "black_hole.rb":
     """
@@ -364,6 +372,7 @@ Feature:
     # ~> incorrect_wrapping.rb:1:in `<main>'
     """
 
+
   Scenario: Can deal with hostile environments
     Given the file "bang_object.rb":
     """
@@ -379,6 +388,6 @@ Feature:
     """
     class Object
       def !(a)
-      end
+      end         # => {{method_result :!}}
     end
     """

data/features/safe.feature

@@ -0,0 +1,33 @@
+Feature: Running in safe-mode
+
+  It would be nice to be able to expose SiB via a bot like hubot.
+  To do this, though, you need to be able to trust the code that users submit.
+  I wrote https://github.com/JoshCheek/eval_in to use the https://eval.in
+  website to run code safely. SiB just needs to use it.
+
+  @wip
+  Scenario: Running normal code
+    Given the file 'safe-example1.rb' 'print "hello, #{gets}"'
+    And the stdin content "world"
+    When I run "seeing_is_believing --safe safe-example1.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    print "hello, #{gets}"  # => nil
+
+    # >> hello, world
+    """
+
+  Scenario: Unsafe code
+  Scenario: With --xmpfilter
+  Scenario: With incompatible options
+  Scenario: With --timeout
+  Scenario: With --as
+  Scenario: With --debug
+  Scenario: Wpper-bound number of captures to prevent it from consuming too many resources
+    --program program         # Pass the program to execute as an argument
+    --load-path dir           # a dir that should be added to the $LOAD_PATH
+    --require file            # additional files to be required before running the program
+    --encoding encoding       # sets file encoding, equivalent to Ruby's -Kx (see `man ruby` for valid values)
+    --shebang ruby-executable # if you want SiB to use some ruby other than the one in the path

data/features/support/env.rb

@@ -1,6 +1,22 @@
 require_relative '../../lib/seeing_is_believing/version'
 
 require 'haiti'
+
+module SiBHelpers
+  def method_result(name)
+    @result = def __some_method__; end
+    if :__some_method__ == @result
+      name.inspect
+    elsif nil == @result
+      nil.inspect
+    else
+      raise "huh? #{@result.inspect}"
+    end
+  end
+end
+
+World SiBHelpers
+
 Haiti.configure do |config|
   config.proving_grounds_dir = File.expand_path '../../../proving_grounds', __FILE__
   config.bin_dir             = File.expand_path '../../../bin',             __FILE__
@@ -17,3 +33,7 @@ Then 'stdout is the JSON:' do |json|
   actual   = JSON.parse(@last_executed.stdout)
   expect(actual).to eq expected
 end
+
+Given %q(the file '$filename' '$body') do |filename, body|
+  Haiti::CommandLineHelpers.write_file filename, eval_curlies(body)
+end

data/features/xmpfilter-style.feature

@@ -0,0 +1,156 @@
+@xmpfilter
+Feature: Xmpfilter style
+  Support the same (or highly similar) interface as xmpfilter,
+  so that people who use that lib can easily transition to SiB.
+
+
+  Scenario: --xmpfilter-style Generic updating of marked lines
+    Given the file "magic_comments.rb":
+    """
+    1+1# =>
+    2+2    # => 10
+    "a
+     b" # =>
+    /a
+     b/ # =>
+    1
+    "omg"
+    # =>
+    "omg2"
+    # => "not omg2"
+    """
+    When I run "seeing_is_believing --xmpfilter-style magic_comments.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    1+1# => 2
+    2+2    # => 4
+    "a
+     b" # => "a\n b"
+    /a
+     b/ # => /a\n b/
+    1
+    "omg"
+    # => "omg"
+    "omg2"
+    # => "omg2"
+    """
+
+
+  Scenario: --xmpfilter-style uses pp to inspect annotations whose value comes from the previous line (#44)
+    Given the file "xmpfilter-prev-line1.rb":
+    """
+    { foo: 42,
+      bar: {
+        baz: 1,
+        buz: 2,
+        fuz: 3,
+      },
+      wibble: {
+        magic_word: "xyzzy",
+      }
+    } # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter-prev-line1.rb"
+    Then stdout is:
+    """
+    { foo: 42,
+      bar: {
+        baz: 1,
+        buz: 2,
+        fuz: 3,
+      },
+      wibble: {
+        magic_word: "xyzzy",
+      }
+    } # => {:foo=>42, :bar=>{:baz=>1, :buz=>2, :fuz=>3}, :wibble=>{:magic_word=>"xyzzy"}}
+    # => {:foo=>42,
+    #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+    #     :wibble=>{:magic_word=>"xyzzy"}}
+    """
+
+  Scenario: --xmpfilter-style overrides previous multiline results
+    Given the file "xmpfilter-prev-line2.rb":
+    """
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter-prev-line2.rb | seeing_is_believing --xmpfilter-style"
+    Then stdout is:
+    """
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # => {:foo=>42,
+    #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+    #     :wibble=>{:magic_word=>"xyzzy"}}
+    """
+
+
+  Scenario: --xmpfilter-style respects the line formatting (but not currently alignment strategies, it just preserves submitted alignment)
+    Given the file "xmpfilter_line_lengths.rb":
+    """
+    '1' * 30 # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style --line-length 19 xmpfilter_line_lengths.rb"
+    Then stdout is:
+    """
+    '1' * 30 # => "1...
+    # => "1111111111...
+    """
+
+
+    @josh1
+  Scenario: Errors on annotated lines
+    Given the file "xmpfilter_error_on_annotated_line.rb":
+    """
+    raise "omg" # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter_error_on_annotated_line.rb"
+    Then stderr is empty
+    And the exit status is 1
+    Then stdout is:
+    """
+    raise "omg" # => # ~> RuntimeError: ZOMG\n!!!!
+
+    # ~> RuntimeError
+    # ~> omg
+    # ~>
+    # ~> xmpfilter_error_on_annotated_line.rb:1:in `<main>'
+    """
+
+
+    @josh2
+  Scenario: Errors on unannotated lines
+    Given the file "xmpfilter_error_on_annotated_line.rb":
+    """
+    raise "omg"
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter_error_on_annotated_line.rb"
+    Then stderr is empty
+    And the exit status is 1
+    Then stdout is:
+    """
+    raise "omg" # =>
+    """
+
+
+  Scenario: pp output on line with exception
+
+
+  Scenario: Cleaning previous output
+    Given the file "xmpfilter_cleaning.rb":
+    """
+    1 # => "1...
+    # => "1111111111...
+    #    "1111111111...
+    # normal comment
+    # => 123
+    """
+    When I run "seeing_is_believing --xmpfilter-style --clean xmpfilter_cleaning.rb"
+    Then stdout is:
+    """
+    1
+    # normal comment
+    """

data/lib/seeing_is_believing.rb

@@ -1,12 +1,11 @@
 require 'stringio'
 require 'tmpdir'
-require 'timeout'
 
 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/evaluate_by_moving_files'
-require 'seeing_is_believing/wrap_expressions'
 
 class SeeingIsBelieving
   BLANK_REGEX = /\A\s*\Z/
@@ -17,70 +16,53 @@ class SeeingIsBelieving
 
   def initialize(program, options={})
     @program            = program
-    @matrix_filename    = options.fetch :matrix_filename, 'seeing_is_believing/the_matrix' # how to hijack the env
     @filename           = options[:filename]
     @stdin              = to_stream options.fetch(:stdin, '')
-    @require            = options.fetch :require,   []
+    @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)
     @ruby_executable    = options.fetch :ruby_executable, 'ruby'
     @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
   end
 
   def call
     @memoized_result ||= begin
       new_program = program_that_will_record_expressions
-      debugger.context("TRANSLATED PROGRAM") { new_program }
+      @debugger.context("TRANSLATED PROGRAM") { new_program }
       result = result_for new_program
-      debugger.context("RESULT") { result.inspect }
+      @debugger.context("RESULT") { result.inspect }
       result
     end
   end
 
   private
 
-  attr_reader :debugger
-
   def to_stream(string_or_stream)
     return string_or_stream if string_or_stream.respond_to? :gets
     StringIO.new string_or_stream
   end
 
   def program_that_will_record_expressions
-    WrapExpressions.call "#{@program}\n",
-                         before_all:  "begin; $SiB.number_of_captures = #{number_of_captures_as_str}; ",
-                         after_all:   ";rescue Exception;"\
-                                        "lambda {"\
-                                          "line_number = $!.backtrace.grep(/\#{__FILE__}/).first[/:\\d+/][1..-1].to_i;"\
-                                          "$SiB.record_exception line_number, $!;"\
-                                          "$SiB.exitstatus = 1;"\
-                                          "$SiB.exitstatus = $!.status if $!.kind_of? SystemExit;"\
-                                        "}.call;"\
-                                      "end",
-                         before_each: -> line_number { "$SiB.record_result(#{line_number}, (" },
-                         after_each:  -> line_number { "))" }
+    @record_expressions.call "#{@program.chomp}\n", @number_of_captures
   end
 
   def result_for(program)
     Dir.mktmpdir "seeing_is_believing_temp_dir" do |dir|
       filename = @filename || File.join(dir, 'program.rb')
-      EvaluateByMovingFiles.call program,
-                                 filename,
-                                 input_stream:       @stdin,
-                                 matrix_filename:    @matrix_filename,
-                                 require:            @require,
-                                 load_path:          @load_path,
-                                 encoding:           @encoding,
-                                 timeout:            @timeout,
-                                 ruby_executable:    @ruby_executable,
-                                 debugger:           @debugger
-    end
-  end
 
-  def number_of_captures_as_str
-    return 'Float::INFINITY' if @number_of_captures == Float::INFINITY
-    @number_of_captures.inspect
+      @evaluator.call program,
+                      filename,
+                      input_stream:       @stdin,
+                      require:            @require,
+                      load_path:          @load_path,
+                      encoding:           @encoding,
+                      timeout:            @timeout,
+                      ruby_executable:    @ruby_executable,
+                      debugger:           @debugger
+    end
   end
 end

data/lib/seeing_is_believing/binary.rb

@@ -1,220 +1,125 @@
 require 'seeing_is_believing'
 require 'seeing_is_believing/binary/parse_args'
-require 'seeing_is_believing/binary/add_annotations'
-require 'seeing_is_believing/binary/clean_body'
-require 'timeout'
-
+require 'seeing_is_believing/binary/interpret_flags'
+require 'seeing_is_believing/binary/remove_annotations'
 
 class SeeingIsBelieving
-  class Binary
+  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
 
-    VALUE_MARKER     = "# => "
-    EXCEPTION_MARKER = "# ~> "
-    STDOUT_MARKER    = "# >> "
-    STDERR_MARKER    = "# !> "
-
-    VALUE_REGEX      = /\A#\s*=>/
-    EXCEPTION_REGEX  = /\A#\s*~>/
-    STDOUT_REGEX     = /\A#\s*>>/
-    STDERR_REGEX     = /\A#\s*!>/
-
-
-
-    attr_accessor :argv, :stdin, :stdout, :stderr, :timeout_error, :unexpected_exception
+    def self.call(argv, stdin, stdout, stderr)
+      flags   = ParseArgs.call(argv)
+      options = InterpretFlags.new(flags, stdin, stdout)
 
-    def initialize(argv, stdin, stdout, stderr)
-      self.argv   = argv
-      self.stdin  = stdin
-      self.stdout = stdout
-      self.stderr = stderr
-    end
-
-    def call
-      @exitstatus ||= begin
-        parse_flags
-
-        if    flags_have_errors?                    then print_errors           ; NONDISPLAYABLE_ERROR_STATUS
-        elsif should_print_help?                    then print_help             ; SUCCESS_STATUS
-        elsif should_print_version?                 then print_version          ; SUCCESS_STATUS
-        elsif has_filename? && file_dne?            then print_file_dne         ; NONDISPLAYABLE_ERROR_STATUS
-        elsif should_clean?                         then print_cleaned_program  ; SUCCESS_STATUS
-        elsif invalid_syntax?                       then print_syntax_error     ; NONDISPLAYABLE_ERROR_STATUS
-        elsif (evaluate_program; program_timedout?) then print_timeout_error    ; NONDISPLAYABLE_ERROR_STATUS
-        elsif something_blew_up?                    then print_unexpected_error ; NONDISPLAYABLE_ERROR_STATUS
-        elsif output_as_json?                       then print_result_as_json   ; SUCCESS_STATUS
-        else                                             print_program          ; exit_status
-        end
+      if options.errors.any?
+        stderr.puts options.errors.join("\n")
+        return NONDISPLAYABLE_ERROR_STATUS
       end
-    end
-
-    private
 
-    attr_accessor :flags, :interpolated_program
-
-    def parse_flags
-      self.flags = ParseArgs.call argv, stdout
-    end
-
-    def flags_have_errors?
-      flags[:errors].any?
-    end
-
-    def print_errors
-      stderr.puts flags[:errors].join("\n")
-    end
-
-    def should_print_help?
-      flags[:help]
-    end
-
-    def print_help
-      stdout.puts flags[:help]
-    end
-
-    def should_print_version?
-      flags[:version]
-    end
-
-    def print_version
-      stdout.puts SeeingIsBelieving::VERSION
-    end
-
-    def has_filename?
-      flags[:filename]
-    end
-
-    def file_dne?
-      !File.exist?(flags[:filename])
-    end
-
-    def print_file_dne
-      stderr.puts "#{flags[:filename]} does not exist!"
-    end
-
-    def should_clean?
-      flags[:clean]
-    end
-
-    def print_cleaned_program
-      stdout.print CleanBody.call(body, true)
-    end
+      if options.print_help?  # TODO: Should this be first?
+        stdout.puts options.help_screen
+        return SUCCESS_STATUS
+      end
 
-    def invalid_syntax?
-      !!syntax_error_notice
-    end
+      if options.print_version?
+        stdout.puts SeeingIsBelieving::VERSION
+        return SUCCESS_STATUS
+      end
 
-    def print_syntax_error
-      stderr.puts syntax_error_notice
-    end
+      if options.provided_filename_dne?
+        stderr.puts "#{options.filename} does not exist!"
+        return NONDISPLAYABLE_ERROR_STATUS
+      end
 
-    def evaluate_program
-      self.interpolated_program = annotator.call
-    rescue Timeout::Error
-      self.timeout_error = true
-    rescue Exception
-      self.unexpected_exception = $!
-    end
+      if options.print_cleaned?
+        stdout.print RemoveAnnotations.call(options.prepared_body, true, options.markers)
+        return SUCCESS_STATUS
+      end
 
-    def program_timedout?
-      timeout_error
-    end
+      syntax_error_notice = syntax_error_notice_for(options.body, options.shebang)
+      if syntax_error_notice
+        stderr.puts syntax_error_notice
+        return NONDISPLAYABLE_ERROR_STATUS
+      end
 
-    def print_timeout_error
-      stderr.puts "Timeout Error after #{@flags[:timeout]} seconds!"
-    end
+      results, program_timedout, unexpected_exception =
+        evaluate_program(options.prepared_body, options.lib_options)
 
-    def something_blew_up?
-      !!unexpected_exception
-    end
+      if program_timedout
+        stderr.puts "Timeout Error after #{options.timeout} seconds!"
+        return NONDISPLAYABLE_ERROR_STATUS
+      end
 
-    def print_unexpected_error
       if unexpected_exception.kind_of? BugInSib
         stderr.puts unexpected_exception.message
-      else
-        stderr.puts unexpected_exception.class, unexpected_exception.message, "", unexpected_exception.backtrace
+        return NONDISPLAYABLE_ERROR_STATUS
       end
-    end
-
-    def output_as_json?
-      flags[:result_as_json]
-    end
 
-    def print_program
-      stdout.print interpolated_program
-    end
+      if unexpected_exception
+        stderr.puts unexpected_exception.class,
+                    unexpected_exception.message,
+                    "",
+                    unexpected_exception.backtrace
+        return NONDISPLAYABLE_ERROR_STATUS
+      end
 
-    def body
-      @body ||= (flags[:program] || (file_is_on_stdin? && stdin.read) || File.read(flags[:filename]))
-    end
+      if options.result_as_json?
+        require 'json'
+        stdout.puts JSON.dump(result_as_data_structure(results))
+        return SUCCESS_STATUS
+      end
 
-    def annotator
-      @annotator ||= AddAnnotations.new body, flags.merge(stdin: (file_is_on_stdin? ? '' : stdin))
-    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)
 
-    def results
-      annotator.results
+      if options.inherit_exit_status?
+        results.exitstatus
+      elsif results.has_exception?
+        DISPLAYABLE_ERROR_STATUS
+      else
+        SUCCESS_STATUS
+      end
     end
 
-    def file_is_on_stdin?
-      flags[:filename].nil? && flags[:program].nil?
-    end
+    private
 
-    def syntax_error_notice
-      @error_notice = begin
-        out, err, syntax_status = Open3.capture3 flags[:shebang], '-c', stdin_data: body
-        err unless syntax_status.success?
+    def self.syntax_error_notice_for(body, shebang)
+      out, err, syntax_status = Open3.capture3 shebang, '-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
-        nil
-      end
+    rescue Errno::EPIPE
+      return nil
     end
 
-    def print_result_as_json
-      require 'json'
-      stdout.puts JSON.dump result_as_data_structure
+    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 result_as_data_structure
-      results = annotator.results
+    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:   (if results.has_exception?
-                       { line_number_in_this_file: results.each_with_line_number.find { |line_number, result| result.has_exception? }.first,
-                         class_name:               results.exception.class_name,
-                         message:                  results.exception.message,
-                         backtrace:                results.exception.backtrace,
-                       }
-                     end),
-        lines:       results.each_with_line_number.each_with_object(Hash.new) { |(line_number, result), hash|
-                       hash[line_number] = { results:   result.to_a,
-                                             exception: (if result.has_exception?
-                                                          { class_name:               results.exception.class_name,
-                                                            message:                  results.exception.message,
-                                                            backtrace:                results.exception.backtrace,
-                                                          }
-                                                        end)
-                       }
-                     },
+        exception:   exception,
+        lines:       results.each.with_object(Hash.new).with_index(1) { |(result, hash), line_number| hash[line_number] = result },
       }
     end
-
-    def exit_status
-      if flags[:inherit_exit_status]
-        results.exitstatus
-      elsif results.has_exception?
-        DISPLAYABLE_ERROR_STATUS
-      else
-        SUCCESS_STATUS
-      end
-    end
-
   end
 end