seeing_is_believing 0.0.3 → 0.0.4

data/lib/seeing_is_believing/result.rb

@@ -1,50 +1,56 @@
-class SeeingIsBelieving
+require 'seeing_is_believing/has_exception'
+require 'seeing_is_believing/tracks_line_numbers_seen'
 
+class SeeingIsBelieving
   class Result
-    module HasException
-      attr_accessor :exception
-      alias has_exception? exception
+
+    Line = Class.new(Array) { include HasException }
+
+    include HasException
+    include TracksLineNumbersSeen
+
+    attr_accessor :stdout, :stderr
+
+    def has_stdout?
+      stdout && !stdout.empty?
     end
 
-    attr_reader :min_line_number, :max_line_number
+    def has_stderr?
+      stderr && !stderr.empty?
+    end
 
     def initialize
       @min_line_number = @max_line_number = 1
     end
 
     def record_result(line_number, value)
-      contains_line_number line_number
-      results[line_number] << value.inspect
+      track_line_number line_number
+      results(line_number) << value.inspect
       value
     end
 
     def record_exception(line_number, exception)
-      contains_line_number line_number
-      results[line_number].exception = exception
+      self.exception = exception
+      track_line_number line_number
+      results(line_number).exception = exception
     end
 
     def [](line_number)
-      results[line_number]
+      results(line_number)
     end
 
-    # probably not really useful, just exists to satisfy the tests
+    # probably not really useful, just exists to satisfy the tests, which specified too simple of an interface
     def to_a
       (min_line_number..max_line_number).map do |line_number|
         [line_number, [*self[line_number], *Array(self[line_number].exception)]]
       end
     end
 
-    def contains_line_number(line_number)
-      @min_line_number = line_number if line_number < @min_line_number
-      @max_line_number = line_number if line_number > @max_line_number
-    end
-
     private
 
-    def results
-      @results ||= Hash.new do |hash, line_number|
-        hash[line_number] = Array.new.extend HasException
-      end
+    def results(line_number)
+      @results ||= Hash.new
+      @results[line_number] ||= Line.new
     end
   end
 end

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -1,49 +1,131 @@
 require 'ripper'
 
-class SyntaxAnalyzer < Ripper::SexpBuilder
-
-  # I don't actually know if all of the error methods should invoke has_error!
-  # or just parse errors. I don't actually know how to produce the other errors O.o
-  #
-  # Here is what it is defining as of ruby-1.9.3-p125:
-  #   on_alias_error
-  #   on_assign_error
-  #   on_class_name_error
-  #   on_param_error
-  #   on_parse_error
-  instance_methods.grep(/error/i).each do |error_meth|
-    class_eval "
-      def #{error_meth}(*)
+class SeeingIsBelieving
+  class SyntaxAnalyzer < Ripper::SexpBuilder
+
+    # HELPERS
+
+    def self.parsed(code)
+      instance = new code
+      instance.parse
+      instance
+    end
+
+    # We have to do this b/c Ripper sometimes calls on_tstring_end even when the string doesn't get ended
+    # e.g. SyntaxAnalyzer.new('"a').parse
+    def ends_match?(beginning, ending)
+      return false unless beginning && ending
+      return beginning == ending if beginning.size == 1
+      case beginning[-1]
+      when '<' then '>' == ending
+      when '(' then ')' == ending
+      when '[' then ']' == ending
+      when '{' then '}' == ending
+      else
+        beginning[-1] == ending
+      end
+    end
+
+    # SYNTACTIC VALIDITY
+
+    # I don't actually know if all of the error methods should set @has_error
+    # or just parse errors. I don't actually know how to produce the other errors O.o
+    #
+    # Here is what it is defining as of ruby-1.9.3-p125:
+    #   on_alias_error
+    #   on_assign_error
+    #   on_class_name_error
+    #   on_param_error
+    #   on_parse_error
+    instance_methods.grep(/error/i).each do |error_meth|
+      super_meth = instance_method error_meth
+      define_method error_meth do |*args, &block|
         @has_error = true
-        super
+        super_meth.bind(self).call(*args, &block)
       end
-    "
-  end
+    end
 
-  def on_comment(*)
-    @has_comment = true
-    super
-  end
+    def self.valid_ruby?(code)
+      parsed(code).valid_ruby?
+    end
 
-  def self.parsed(code)
-    instance = new code
-    instance.parse
-    instance
-  end
+    def valid_ruby?
+      !invalid_ruby?
+    end
 
-  def self.valid_ruby?(code)
-    !parsed(code).has_error?
-  end
+    def invalid_ruby?
+      @has_error || unclosed_string? || unclosed_regexp?
+    end
 
-  def self.ends_in_comment?(code)
-    parsed(code.lines.to_a.last.to_s).has_comment?
-  end
+    # STRINGS
 
-  def has_error?
-    @has_error
-  end
+    def self.unclosed_string?(code)
+      parsed(code).unclosed_string?
+    end
+
+    def string_opens
+      @string_opens ||= []
+    end
+
+    def on_tstring_beg(beginning)
+      string_opens.push beginning
+      super
+    end
+
+    def on_tstring_end(ending)
+      string_opens.pop if ends_match? string_opens.last, ending
+      super
+    end
+
+    def unclosed_string?
+      string_opens.any?
+    end
+
+    # REGEXPS
+
+    def self.unclosed_regexp?(code)
+      parsed(code).unclosed_regexp?
+    end
+
+    def regexp_opens
+      @regexp_opens ||= []
+    end
+
+    def on_regexp_beg(beginning)
+      regexp_opens.push beginning
+      super
+    end
+
+    def on_regexp_end(ending)
+      regexp_opens.pop if ends_match? regexp_opens.last, ending
+      super
+    end
+
+    def unclosed_regexp?
+      regexp_opens.any?
+    end
+
+    # COMMENTS
+
+    def self.ends_in_comment?(code)
+      parsed(code.lines.to_a.last.to_s).has_comment?
+    end
+
+    def has_comment?
+      @has_comment
+    end
+
+    def on_comment(*)
+      @has_comment = true
+      super
+    end
+
+    # RETURNS
 
-  def has_comment?
-    @has_comment
+    # this is conspicuosuly inferior, but I can't figure out how to actually parse it
+    # see: http://www.ruby-forum.com/topic/4409633
+    def self.will_return?(code)
+      /(^|\s)return.*?\Z$/ =~ code
+    end
   end
 end

data/lib/seeing_is_believing/the_matrix.rb

@@ -0,0 +1,19 @@
+# WARNING: DO NOT REQUIRE THIS FILE, IT WILL FUCK YOU UP!!!!!!
+
+
+require 'stringio'
+real_stdout = STDOUT
+real_stderr = STDERR
+STDOUT = $stdout = fake_stdout = StringIO.new
+STDERR = $stderr = fake_stderr = StringIO.new
+
+require 'yaml'
+require 'seeing_is_believing/result'
+$seeing_is_believing_current_result = SeeingIsBelieving::Result.new
+
+at_exit do
+  $seeing_is_believing_current_result.stdout = fake_stdout.string
+  $seeing_is_believing_current_result.stderr = fake_stderr.string
+
+  real_stdout.write YAML.dump $seeing_is_believing_current_result
+end

data/lib/seeing_is_believing/tracks_line_numbers_seen.rb

@@ -0,0 +1,18 @@
+class SeeingIsBelieving
+  module TracksLineNumbersSeen
+    INITIAL_LINE_NUMBER = 1 # uhm, should this change to 0?
+
+    def track_line_number(line_number)
+      @min_line_number = line_number if line_number < min_line_number
+      @max_line_number = line_number if line_number > max_line_number
+    end
+
+    def min_line_number
+      @min_line_number || INITIAL_LINE_NUMBER
+    end
+
+    def max_line_number
+      @max_line_number || INITIAL_LINE_NUMBER
+    end
+  end
+end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/seeing_is_believing.rb

@@ -1,22 +1,28 @@
 require 'stringio'
+require 'tmpdir'
 
 require 'seeing_is_believing/result'
 require 'seeing_is_believing/expression_list'
+require 'seeing_is_believing/evaluate_by_moving_files'
 
 # might not work on windows b/c of assumptions about line ends
 class SeeingIsBelieving
-  def initialize(string_or_stream)
-    @stream = to_stream string_or_stream
-    @result = Result.new
+  include TracksLineNumbersSeen
+  BLANK_REGEX = /\A\s*\Z/
+
+  def initialize(string_or_stream, options={})
+    @string   = string_or_stream
+    @stream   = to_stream string_or_stream
+    @filename = options[:filename]
   end
 
   def call
     @memoized_result ||= begin
       program = ''
-      program << expression_list.call until stream.eof?
-      $seeing_is_believing_current_result = @result # can we make this a threadlocal var on the class?
-      TOPLEVEL_BINDING.eval record_exceptions_in(program), 'program.rb', 1
-      @result
+      program << expression_list.call until eof? || data_segment?
+      program = record_exceptions_in program
+      program << "\n" << the_rest_of_the_stream if data_segment?
+      result_for program, min_line_number, max_line_number
     end
   end
 
@@ -25,11 +31,11 @@ class SeeingIsBelieving
   attr_reader :stream
 
   def expression_list
-    @expression_list ||= ExpressionList.new generator: lambda { stream.gets.chomp },
+    @expression_list ||= ExpressionList.new generator:   lambda { get_next_line },
                                             on_complete: lambda { |line, children, completions, line_number|
-                                              @result.contains_line_number line_number
-                                              expression = [line, *children, *completions].join("\n")
-                                              if expression == '' || ends_in_comment?(expression)
+                                              track_line_number line_number
+                                              expression = [line, *children, *completions].map(&:chomp).join("\n")
+                                              if expression =~ BLANK_REGEX || SyntaxAnalyzer.ends_in_comment?(expression) || SyntaxAnalyzer.will_return?(expression)
                                                 expression + "\n"
                                               else
                                                 record_yahself(expression, line_number) + "\n"
@@ -56,7 +62,42 @@ class SeeingIsBelieving
     "end"
   end
 
-  def ends_in_comment?(expression)
-    SyntaxAnalyzer.ends_in_comment? expression
+  def result_for(program, min_line_number, max_line_number)
+    Dir.mktmpdir "seeing_is_believing_temp_dir" do |dir|
+      filename = @filename || File.join(dir, 'program.rb')
+      EvaluateByMovingFiles.new(program, filename).call.tap do |result|
+        result.track_line_number min_line_number
+        result.track_line_number max_line_number
+      end
+    end
+  end
+
+  def eof?
+    peek_next_line.nil?
+  end
+
+  def data_segment?
+    peek_next_line == '__END__'
+  end
+
+  def peek_next_line
+    @next_line ||= begin
+      line = stream.gets
+      line && line.chomp
+    end
+  end
+
+  def get_next_line
+    if @next_line
+      line = peek_next_line
+      @next_line = nil
+      line
+    else
+      peek_next_line && get_next_line
+    end
+  end
+
+  def the_rest_of_the_stream
+    get_next_line << "\n" << stream.read
   end
 end

data/seeing_is_believing.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rspec",    "~> 2.12.0"
   s.add_development_dependency "cucumber", "~> 1.2.1"
+  s.add_development_dependency "ichannel", "~> 5.1.1"
 end

data/spec/evaluate_by_moving_files_spec.rb

@@ -0,0 +1,68 @@
+require 'seeing_is_believing/evaluate_by_moving_files'
+
+describe SeeingIsBelieving::EvaluateByMovingFiles do
+  let(:filedir)  { File.expand_path '../../proving_grounds', __FILE__ }
+  let(:filename) { File.join filedir, 'some_filename' }
+
+  def invoke(program)
+    evaluator = described_class.new(program, filename)
+    FileUtils.rm_f evaluator.temp_filename
+    evaluator.call
+  end
+
+  it 'evaluates the code when the file DNE' do
+    FileUtils.rm_f filename
+    invoke('print 1').stdout.should == '1'
+  end
+
+  it 'evaluates the code when the file Exists' do
+    FileUtils.touch filename
+    invoke('print 1').stdout.should == '1'
+  end
+
+  it 'raises an error when the temp file already exists' do
+    evaluator = described_class.new('', filename)
+    FileUtils.touch evaluator.temp_filename
+    expect { evaluator.call }.to raise_error SeeingIsBelieving::TempFileAlreadyExists
+  end
+
+  it 'evaluates the code as the given file' do
+    invoke('print __FILE__').stdout.should == filename
+  end
+
+  it 'does not change the original file' do
+    File.open(filename, 'w') { |f| f.write "ORIGINAL" }
+    invoke '1 + 1'
+    File.read(filename).should == "ORIGINAL"
+  end
+
+  it 'uses HardCoreEnsure to move the file back' do
+    evaluator = described_class.new 'PROGRAM', filename, error_stream: StringIO.new
+    File.open(filename, 'w') { |f| f.write 'ORIGINAL' }
+    FileUtils.rm_rf evaluator.temp_filename
+    SeeingIsBelieving::HardCoreEnsure.should_receive(:call) do |options|
+      # initial state
+      File.exist?(evaluator.temp_filename).should == false
+      File.read(filename).should == 'ORIGINAL'
+
+      # after code
+      options[:code].call rescue nil
+      File.read(evaluator.temp_filename).should == 'ORIGINAL'
+      File.read(filename).should == 'PROGRAM'
+
+      # after ensure
+      options[:ensure].call
+      File.read(filename).should == 'ORIGINAL'
+      File.exist?(evaluator.temp_filename).should == false
+    end
+    evaluator.call
+  end
+
+  it 'prints some error handling code to stderr if it fails' do
+    stderr    = StringIO.new
+    evaluator = described_class.new 'raise "omg"', filename, error_stream: stderr
+    FileUtils.rm_f evaluator.temp_filename
+    expect { evaluator.call }.to raise_error
+    stderr.string.should include "It blew up"
+  end
+end

data/spec/expression_list_spec.rb

@@ -105,11 +105,29 @@ describe SeeingIsBelieving::ExpressionList do
                      "end end"\
   end
 
-  example "example; smoke test debug option" do
-    stream = StringIO.new
-    result = call %w[a+ b], debug: true, debug_stream: stream do |line, children, completions, line_number|
-      [line, *children, *completions].join("\n")
+  example 'example: multiline strings with valid code in them' do
+    block_invocations = 0
+    call ["'", "1", "'"] do |*expressions, line_number|
+      expressions.join('').should == "'1'"
+      line_number.should == 3
+      block_invocations += 1
+    end
+    block_invocations.should == 1
+  end
+
+  example 'example: multiline regexps with valid code in them' do
+    block_invocations = 0
+    call ['/', '1', '/'] do |*expressions, line_number|
+      expressions.join('').should == "/1/"
+      line_number.should == 3
+      block_invocations += 1
     end
+    block_invocations.should == 1
+  end
+
+  example "example: smoke test debug option" do
+    stream = StringIO.new
+    call(%w[a+ b], debug: true, debug_stream: stream) { |*expressions, _| expressions.join("\n") }
     stream.string.should include "GENERATED"
     stream.string.should include "REDUCED"
   end

data/spec/hard_core_ensure_spec.rb

@@ -0,0 +1,73 @@
+require 'ichannel'
+require 'seeing_is_believing/hard_core_ensure'
+
+describe SeeingIsBelieving::HardCoreEnsure do
+  def call(options)
+    described_class.new(options).call
+  end
+
+  it "raises an argument error if it doesn't get a code proc" do
+    expect { call ensure: -> {} }.to raise_error ArgumentError, "Must pass the :code key"
+  end
+
+  it "raises an argument error if it doesn't get an ensure proc" do
+    expect { call code: -> {} }.to raise_error ArgumentError, "Must pass the :ensure key"
+  end
+
+  it "raises an argument error if it gets any other keys" do
+    expect { call code: -> {}, ensure: -> {}, other: 123 }.to \
+      raise_error ArgumentError, "Unknown key: :other"
+
+    expect { call code: -> {}, ensure: -> {}, other1: 123, other2: 456 }.to \
+      raise_error ArgumentError, "Unknown keys: :other1, :other2"
+  end
+
+  it 'invokes the code and returns the value' do
+    call(code: -> { :result }, ensure: -> {}).should == :result
+  end
+
+  it 'invokes the ensure after the code' do
+    seen = []
+    call code: -> { seen << :code }, ensure: -> { seen << :ensure }
+    seen.should == [:code, :ensure]
+  end
+
+  it 'invokes the ensure even if an exception is raised' do
+    ensure_invoked = false
+    expect do
+      call code: -> { raise Exception, 'omg!' }, ensure: -> { ensure_invoked = true }
+    end.to raise_error Exception, 'omg!'
+    ensure_invoked.should == true
+  end
+
+  it 'invokes the code even if an interrupt is sent and there is a default handler' do
+    channel = IChannel.new Marshal
+    pid = fork do
+      old_handler = trap('INT') { channel.put "old handler invoked" }
+      call code: -> { sleep 0.1 }, ensure: -> { channel.put "ensure invoked" }
+      trap 'INT', old_handler
+    end
+    sleep 0.05
+    Process.kill 'INT', pid
+    Process.wait pid
+    channel.get.should == "ensure invoked"
+    channel.get.should == "old handler invoked"
+    channel.should_not be_readable
+  end
+
+  it 'invokes the code even if an interrupt is sent and interrupts are set to ignore' do
+    channel = IChannel.new Marshal
+    pid = fork do
+      old_handler = trap 'INT', 'IGNORE'
+      result = call code: -> { sleep 0.1; 'code result' }, ensure: -> { channel.put "ensure invoked" }
+      channel.put result
+      trap 'INT', old_handler
+    end
+    sleep 0.05
+    Process.kill 'INT', pid
+    Process.wait pid
+    channel.get.should == "ensure invoked"
+    channel.get.should == 'code result'
+    channel.should_not be_readable
+  end
+end