seeing_is_believing 0.0.3 → 0.0.4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    seeing_is_believing (0.0.1)
+    seeing_is_believing (0.0.4)
 
 GEM
   remote: http://rubygems.org/
@@ -15,6 +15,7 @@ GEM
     diff-lcs (1.1.3)
     gherkin (2.11.5)
       json (>= 1.4.6)
+    ichannel (5.1.1)
     json (1.7.6)
     rspec (2.12.0)
       rspec-core (~> 2.12.0)
@@ -30,5 +31,6 @@ PLATFORMS
 
 DEPENDENCIES
   cucumber (~> 1.2.1)
+  ichannel (~> 5.1.1)
   rspec (~> 2.12.0)
   seeing_is_believing!

data/Readme.md

@@ -9,8 +9,8 @@ Reeaally rough at the moment, but it works for simple examples.
 
 Also comes with a binary to show how it might be used.
 
-Use
-===
+Use The Binary
+==============
 
 ```ruby
 # $ seeing_is_believing proving_grounds/basic_functionality.rb
@@ -21,6 +21,8 @@ end             # => 5
 def meth(n)
   n             # => "12", "34"
 end             # => nil
+
+# some invocations
 meth "12"       # => "12"
 meth "34"       # => "34"
 ```
@@ -37,6 +39,27 @@ raise "ZOMG!"  # ~> RuntimeError: ZOMG!
 ZOMG!
 ```
 
+Use The Lib
+===========
+
+```ruby
+require 'seeing_is_believing'
+
+believer = SeeingIsBelieving.new("%w[a b c].each do |i|
+                                    i.upcase
+                                  end")
+
+result = believer.call
+result      # => #<SeeingIsBelieving::Result:0x007faeed1a5b78 @max_line_number=3, @min_line_number=1, @results={2=>['"A"', '"B"', '"C"'], 3=>['["a", "b", "c"]']}>
+
+result.to_a # => [ [1, []],
+            #      [2, ['"A"', '"B"', '"C"']],
+            #      [3, ['["a", "b", "c"]']]
+            #    ]
+
+result[2]   # => ['"A"', '"B"', '"C"']
+```
+
 Install
 =======
 
@@ -49,11 +72,10 @@ Or if you haven't fixed your gem home, and you aren't using any version managers
 Known Issues
 ============
 
-* comments will kill it, probably going to have to actually parse the code to fix this
-* multi-line strings will probably kill it, probably going to have to actually parse the code to fix this
-* I have no idea what happens if you talk to stdout/stderr directly. This should become a non-issue if we evaluate it in its own process like xmpfilter.
-* If it dies, it will take your program with it. Same as above. (e.g. running the binary against itself will cause it to recursively invoke itself forever WARNING: DON'T REALLY DO THAT, ITS CRAYAZAY)
 * No idea what happens if you give it a syntactically invalid file. It probably just raises an exception, but might possibly freeze up or something.
+* heredocs breaks things maybe also `BEGIN/END` and `=begin/=end`
+* There are expressions which continue on the next line even though the previous line is a valid expression, e.g. "3\n.times { |i| i }" which will blow up. This is a fundamental flaw in the algorithm and will either require a smarter algorithm, or some sort of more sophisticated parsing in order to handle correctly
+* Probably doesn't handle stdin correctly
 
 License
 =======

data/bin/seeing_is_believing

@@ -6,9 +6,8 @@ require 'seeing_is_believing/example_use'
 status = 0
 
 ARGV.each do |filename|
-  believer = SeeingIsBelieving::ExampleUse.new(File.read filename)
-  believer.call
-  $stdout.puts believer.output
+  believer = SeeingIsBelieving::ExampleUse.new File.read(filename), filename
+  $stdout.puts believer.call
   if believer.has_exception?
     $stderr.puts believer.exception.message
     status = 1

data/features/binary.feature

@@ -19,6 +19,11 @@ Feature: Running the binary
     # some invocations
     meth "12"
     meth "34"
+
+    # multilinezzz
+    "a
+     b
+     c"
     """
     When I run "seeing_is_believing basic_functionality.rb"
     Then stderr is empty
@@ -36,6 +41,11 @@ Feature: Running the binary
     # some invocations
     meth "12"       # => "12"
     meth "34"       # => "34"
+
+    # multilinezzz
+    "a
+     b
+     c"             # => "a\n b\n c"
     """
 
   Scenario: Raising exceptions
@@ -55,7 +65,86 @@ Feature: Running the binary
     1 + 1
     """
 
+  Scenario: Passing previous output back into input
+    Given the file "previous_output.rb":
+    """
+    1 + 1  # => not 2
+    2 + 2  # ~> Exception, something
+
+
+    # >> some stdout output
+
+    # !> some stderr output
+    __END__
+    """
+    When I run "seeing_is_believing previous_output.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    1 + 1  # => 2
+    2 + 2  # => 4
+
+    __END__
+    """
+
   Scenario: Printing within the file
+    Given the file "printing.rb":
+    """
+    print "hel"
+    puts  "lo!"
+    puts  ":)"
+    $stderr.puts "goodbye"
+    """
+    When I run "seeing_is_believing printing.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    print "hel"             # => nil
+    puts  "lo!"             # => nil
+    puts  ":)"              # => nil
+    $stderr.puts "goodbye"  # => nil
+
+    # >> hello!
+    # >> :)
+
+    # !> goodbye
+    """
+
+  Scenario: Respects macros
+    Given the file "some_dir/uses_macros.rb":
+    """
+    __FILE__
+    __LINE__
+    $stdout.puts "omg"
+    $stderr.puts "hi"
+    DATA.read
+    __LINE__
+    __END__
+    1
+    2
+    """
+    When I run "seeing_is_believing some_dir/uses_macros.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    __FILE__            # => "{{CommandLineHelpers.path_to 'some_dir/uses_macros.rb'}}"
+    __LINE__            # => 2
+    $stdout.puts "omg"  # => nil
+    $stderr.puts "hi"   # => nil
+    DATA.read           # => "1\n2"
+    __LINE__            # => 6
+
+    # >> omg
+
+    # !> hi
+    __END__
+    1
+    2
+    """
+
   Scenario: Requiring other files
   Scenario: Syntactically invalid file
   Scenario: Passing a nonexistent file

data/features/step_definitions/steps.rb

@@ -7,11 +7,11 @@ When 'I run "$command"' do |command|
 end
 
 Then /^(stderr|stdout) is:$/ do |stream_name, output|
-  @last_executed.send(stream_name).chomp.should == output
+  @last_executed.send(stream_name).chomp.should == eval_curlies(output)
 end
 
 Then /^(stderr|stdout) is "(.*?)"$/ do |stream_name, output|
-  @last_executed.send(stream_name).chomp.should == output
+  @last_executed.send(stream_name).chomp.should == eval_curlies(output)
 end
 
 Then 'the exit status is $status' do |status|

data/features/support/env.rb

@@ -13,14 +13,15 @@ module CommandLineHelpers
 
   def write_file(filename, body)
     in_proving_grounds do
+      FileUtils.mkdir_p File.dirname filename
       File.open(filename, 'w') { |file| file.write body }
     end
   end
 
   def execute(command)
     in_proving_grounds do
-      command = "PATH=#{bin_dir}:$PATH #{command}"
-      Invocation.new *Open3.capture3(command)
+      bin_in_path = {'PATH' => "#{bin_dir}:#{ENV['PATH']}"}
+      Invocation.new *Open3.capture3(bin_in_path, command)
     end
   end
 
@@ -47,6 +48,18 @@ module CommandLineHelpers
   def bin_dir
     File.join root_dir, "bin"
   end
+
+  def path_to(filename)
+    in_proving_grounds { File.join proving_grounds_dir, filename }
+  end
 end
 
 CommandLineHelpers.make_proving_grounds
+
+module GeneralHelpers
+  def eval_curlies(string)
+    string.gsub(/{{(.*?)}}/) { eval $1 }
+  end
+end
+
+World GeneralHelpers

data/lib/seeing_is_believing/error.rb

@@ -0,0 +1,7 @@
+class SeeingIsBelieving
+  # all our errors will inherit from this so that a user
+  # can catch any error generated by this lib
+  SeeingIsBelievingError = Class.new StandardError
+
+  TempFileAlreadyExists = Class.new SeeingIsBelievingError
+end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -0,0 +1,118 @@
+# Not sure what the best way to evaluate these is
+# This approach will move the old file out of the way,
+# write the program in its place, invoke it, and move it back.
+#
+# Another option is to replace __FILE__ macros ourselves
+# and then write to a temp file but evaluate in the context
+# of the expected directory. I'm not doing that just because
+# I don't think the __FILE__ macro can be replaced correctly
+# without parsing the code, changing the AST, and then
+# regenerating it, which I'm not good enough to do. Though
+# I did look at Ripper, and it will invoke on_kw("__FILE__")
+# when it sees this.
+
+require 'yaml'
+require 'open3'
+require 'fileutils'
+require 'seeing_is_believing/error'
+require 'seeing_is_believing/result'
+require 'seeing_is_believing/hard_core_ensure'
+
+class SeeingIsBelieving
+  class EvaluateByMovingFiles
+    attr_accessor :program, :filename, :error_stream
+
+    def initialize(program, filename, options={})
+      self.program      = program
+      self.filename     = File.expand_path(filename)
+      self.error_stream = options.fetch :error_stream, $stderr
+    end
+
+    def call
+      @result ||= HardCoreEnsure.call(
+        code: -> {
+          dont_overwrite_existing_tempfile!
+          move_file_to_tempfile
+          write_program_to_file
+          begin
+            evaluate_file
+            fail unless exitstatus.success?
+            deserialize_result
+          rescue Exception
+            record_error
+            raise $!
+          end
+        },
+        ensure: -> {
+          restore_backup
+        }
+      )
+    end
+
+    def file_directory
+      File.dirname filename
+    end
+
+    def temp_filename
+      File.join file_directory, "seeing_is_believing_backup.#{File.basename filename}"
+    end
+
+    private
+
+    attr_accessor :stdout, :stderr, :exitstatus
+
+    def dont_overwrite_existing_tempfile!
+      return unless File.exist? temp_filename
+      raise TempFileAlreadyExists,
+        "Trying to back up #{filename.inspect} (FILE) to #{temp_filename.inspect} (TEMPFILE) but TEMPFILE already exists."\
+        " You should check the contents of these files. If FILE is correct, then delete TEMPFILE."\
+        " Otherwise rename TEMPFILE to FILE."
+    end
+
+    def move_file_to_tempfile
+      return unless File.exist? filename
+      FileUtils.mv filename, temp_filename
+      @was_backed_up = true
+    end
+
+    def restore_backup
+      return unless @was_backed_up
+      FileUtils.mv temp_filename, filename
+    end
+
+    def write_program_to_file
+      File.open(filename, 'w') { |f| f.write program.to_s }
+    end
+
+    def evaluate_file
+      self.stdout, self.stderr, self.exitstatus = Open3.capture3(
+        'ruby', '-W0',                                     # no warnings (b/c I hijack STDOUT/STDERR)
+                '-I', File.expand_path('../..', __FILE__), # fix load path
+                '-r', 'seeing_is_believing/the_matrix',    # hijack the environment so it can be recorded
+                '-C', file_directory,                      # run in the file's directory
+                filename
+      )
+    end
+
+    def fail
+      raise "Exitstatus: #{exitstatus.inspect},\nError: #{stderr.inspect}"
+    end
+
+    def deserialize_result
+      YAML.load stdout
+    end
+
+    def record_error
+      error_stream.puts "It blew up. Not too surprising given that seeing_is_believing is pretty rough around the edges, but still this shouldn't happen."
+      error_stream.puts "Please log an issue at: https://github.com/JoshCheek/seeing_is_believing/issues"
+      error_stream.puts
+      error_stream.puts "Program: #{program.inspect}"
+      error_stream.puts
+      error_stream.puts "Stdout: #{stdout.inspect}"
+      error_stream.puts
+      error_stream.puts "Stderr: #{stderr.inspect}"
+      error_stream.puts
+      error_stream.puts "Status: #{exitstatus.inspect}"
+    end
+  end
+end

data/lib/seeing_is_believing/example_use.rb

@@ -1,50 +1,96 @@
 require 'seeing_is_believing'
+require 'seeing_is_believing/has_exception'
 
 class SeeingIsBelieving
   class ExampleUse
-    attr_accessor :exception
+    include HasException
 
-    def initialize(body)
-      self.body = body
+       STDOUT_PREFIX = '# >>'
+       STDERR_PREFIX = '# !>'
+    EXCEPTION_PREFIX = '# ~>'
+       RESULT_PREFIX = '# =>'
+
+    def initialize(body, filename=nil)
+      self.body     = remove_previous_output_from body
+      self.filename = filename
+    end
+
+    def new_body
+      @new_body ||= ''
     end
 
     def call
-      body.each_line.with_index 1 do |line, index|
-        line_results = results[index]
-        self.exception = line_results.exception if line_results.has_exception?
-        output << format_line(line.chomp, line_results)
-      end
-      output
+      evaluate_program
+      inherit_exception
+      add_each_line_until_data_segment
+      add_stdout
+      add_stderr
+      add_data_segment
+      new_body
     end
 
-    def output
-      @result ||= ''
+    private
+
+    attr_accessor :body, :filename, :file_result
+
+    def evaluate_program
+      self.file_result = SeeingIsBelieving.new(body, filename: filename).call
     end
 
-    alias has_exception? exception
+    def inherit_exception
+      self.exception = file_result.exception
+    end
 
-    private
+    def add_each_line_until_data_segment
+      body.each_line.with_index 1 do |line, index|
+        break if start_of_data_segment? line
+        new_body << format_line(line.chomp, file_result[index])
+      end
+    end
 
-    attr_accessor :body
+    def add_data_segment
+      body.each_line
+          .drop_while { |line| not start_of_data_segment? line }
+          .each { |line| new_body << line }
+    end
 
-    def results
-      @results ||= SeeingIsBelieving.new(body).call
+    def start_of_data_segment?(line)
+      line.chomp == '__END__'
     end
 
     # max line length of the body + 2 spaces for padding
     def line_length
       @line_length ||= 2 + body.each_line
                                .map(&:chomp)
+                               .take_while { |line| not start_of_data_segment? line }
                                .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
                                .map(&:length)
                                .max
     end
 
+    def remove_previous_output_from(string)
+      string.gsub(/\s+(#{EXCEPTION_PREFIX}|#{RESULT_PREFIX}).*?$/, '')
+            .gsub(/(\n)?(^#{STDOUT_PREFIX}[^\n]*\r?\n?)+/m,        '')
+            .gsub(/(\n)?(^#{STDERR_PREFIX}[^\n]*\r?\n?)+/m,        '')
+    end
+
+    def add_stdout
+      return unless file_result.has_stdout?
+      new_body << "\n"
+      file_result.stdout.each_line { |line| new_body << "#{STDOUT_PREFIX} #{line}" }
+    end
+
+    def add_stderr
+      return unless file_result.has_stderr?
+      new_body << "\n"
+      file_result.stderr.each_line { |line| new_body << "#{STDERR_PREFIX} #{line}" }
+    end
+
     def format_line(line, line_results)
       if line_results.has_exception?
-        sprintf "%-#{line_length}s# ~> %s: %s\n", line, line_results.exception.class, line_results.exception.message
+        sprintf "%-#{line_length}s#{EXCEPTION_PREFIX} %s: %s\n", line, line_results.exception.class, line_results.exception.message
       elsif line_results.any?
-        sprintf "%-#{line_length}s# => %s\n", line, line_results.join(', ')
+        sprintf "%-#{line_length}s#{RESULT_PREFIX} %s\n", line, line_results.join(', ')
       else
         line + "\n"
       end

data/lib/seeing_is_believing/expression_list.rb

@@ -1,6 +1,8 @@
 require 'open3'
 require 'seeing_is_believing/syntax_analyzer'
 
+# A lot of colouring going on in this file, maybe should extract a debugging object to contain it
+
 class SeeingIsBelieving
   class ExpressionList
     PendingExpression = Struct.new :expression, :children do
@@ -18,60 +20,70 @@ class SeeingIsBelieving
       self.should_debug = options.fetch :debug, false
       self.generator    = options.fetch :generator
       self.on_complete  = options.fetch :on_complete
-      self.line_number  = 0
-      self.list         = []
+      @line_number      = 0
     end
 
     def call
+      expressions = []
       expression = nil
       begin
-        generate
-        expression = reduce_expressions
-      end until list.empty?
+        pending_expression = generate
+        debug { "GENERATED: #{pending_expression.expression.inspect}, ADDING IT TO #{inspected_expressions expressions}" }
+        expressions << pending_expression
+        expression = reduce expressions
+      end until expressions.empty?
       expression
     end
 
     private
 
-    attr_accessor :debug_stream, :should_debug, :generator, :on_complete, :line_number, :list
+    attr_accessor :debug_stream, :should_debug, :generator, :on_complete, :expressions
 
     def generate
       @line_number += 1
       expression = generator.call
-      debug? && debug("GENERATED: #{expression.inspect}, ADDING IT TO #{inspected_list}")
-      @list << PendingExpression.new(expression, [])
+      PendingExpression.new(expression, [])
     end
 
-    def inspected_list
-      "[#{@list.map { |pe| pe.inspect debug? }.join(', ')}]"
+    def inspected_expressions(expressions)
+      "[#{expressions.map { |pe| pe.inspect debug? }.join(', ')}]"
     end
 
     def debug?
       @should_debug
     end
 
-    def debug(message)
-      @debug_stream.puts message
+    def debug
+      @debug_stream.puts yield if debug?
     end
 
-    def reduce_expressions
-      @list.size.times do |i|
-        # uhm, should this expression we are checking for validity consider the children?
-        expression = @list[i..-1].map(&:expression).join("\n") # must use newline otherwise can get expressions like `a\\+b` that should be `a\\\n+b`, former is invalid
+    def reduce(expressions)
+      expressions.size.times do |i|
+        expression = expressions[i..-1].map(&:expression) # uhm, should this expression we are checking for validity consider the children?
+                                       .join("\n")        # must use newline otherwise can get expressions like `a\\+b` that should be `a\\\n+b`, former is invalid
+        return if children_will_never_be_valid? expression
         next unless valid_ruby? expression
-        result = on_complete.call(@list[i].expression,
-                                  @list[i].children,
-                                  @list[i+1..-1].map { |pe| [pe.expression, pe.children] }.flatten, # hmmm, not sure this is really correct, but it allows it to work for my use cases
+        result = on_complete.call(expressions[i].expression,
+                                  expressions[i].children,
+                                  expressions[i+1..-1].map { |pe| [pe.expression, pe.children] }.flatten, # hmmm, not sure this is really correct, but it allows it to work for my use cases
                                   @line_number)
-        @list = @list[0, i]
-        @list[i-1].children << result unless @list.empty?
-        debug? && debug("REDUCED: #{result.inspect}, LIST: #{inspected_list}")
+        expressions.replace expressions[0, i]
+        expressions[i-1].children << result unless expressions.empty?
+        debug { "REDUCED: #{result.inspect}, LIST: #{inspected_expressions expressions}" }
         return result
       end
     end
 
     def valid_ruby?(expression)
-      SyntaxAnalyzer.valid_ruby? expression
+      valid = SyntaxAnalyzer.valid_ruby? expression
+      debug { "#{valid ? "\e[31mIS NOT VALID:" : "\e[32mIS VALID:"}: #{expression.inspect}\e[0m" }
+      valid
+    end
+
+    def children_will_never_be_valid?(expression)
+      analyzer = SyntaxAnalyzer.new(expression)
+      analyzer.parse
+      analyzer.unclosed_string? || analyzer.unclosed_regexp?
     end
   end
 end

data/lib/seeing_is_believing/hard_core_ensure.rb

@@ -0,0 +1,52 @@
+class SeeingIsBelieving
+  class HardCoreEnsure
+    def self.call(options)
+      new(options).call
+    end
+
+    def initialize(options)
+      self.options = options
+      validate_options
+    end
+
+    def call
+      trap_sigint
+      invoke_code
+    ensure
+      invoke_ensure
+    end
+
+    private
+
+    attr_accessor :options, :ensure_invoked, :old_handler
+
+    def trap_sigint
+      self.old_handler = trap 'INT' do
+        invoke_ensure
+        Process.kill 'INT', $$
+      end
+    end
+
+    def invoke_code
+      options[:code].call
+    end
+
+    def invoke_ensure
+      return if ensure_invoked
+      trap 'INT', old_handler
+      self.ensure_invoked = true
+      options[:ensure].call
+    end
+
+    def validate_options
+      raise ArgumentError, "Must pass the :code key"   unless options.key? :code
+      raise ArgumentError, "Must pass the :ensure key" unless options.key? :ensure
+      unknown_keys = options.keys - [:code, :ensure]
+      if options.size == 3
+        raise ArgumentError, "Unknown key: #{unknown_keys.first.inspect}"
+      elsif options.size > 3
+        raise ArgumentError, "Unknown keys: #{unknown_keys.map(&:inspect).join(', ')}"
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/has_exception.rb

@@ -0,0 +1,6 @@
+class SeeingIsBelieving
+  module HasException
+    attr_accessor :exception
+    alias has_exception? exception
+  end
+end