seeing_is_believing 0.0.5 → 0.0.7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    seeing_is_believing (0.0.4)
+    seeing_is_believing (0.0.6)
 
 GEM
   remote: http://rubygems.org/
@@ -17,6 +17,7 @@ GEM
       json (>= 1.4.6)
     ichannel (5.1.1)
     json (1.7.6)
+    rake (10.0.3)
     rspec (2.12.0)
       rspec-core (~> 2.12.0)
       rspec-expectations (~> 2.12.0)
@@ -32,5 +33,6 @@ PLATFORMS
 DEPENDENCIES
   cucumber (~> 1.2.1)
   ichannel (~> 5.1.1)
+  rake (~> 10.0.3)
   rspec (~> 2.12.0)
   seeing_is_believing!

data/Readme.md

@@ -5,10 +5,11 @@ Evaluates a file, recording the results of each line of code.
 You can then use this to display output values like Bret Victor does with JavaScript in his talk [Inventing on Principle][inventing_on_principle].
 Except, obviously, his is like a million better.
 
-Reeaally rough at the moment, but it works for simple examples.
-
 Also comes with a binary to show how it might be used.
 
+For whatever reason, I can't embed videos, but here's a ~1 minute [video][video] showing it off.
+
+
 Use The Binary
 ==============
 
@@ -63,19 +64,42 @@ result[2]   # => ['"A"', '"B"', '"C"']
 Install
 =======
 
+For now, since Rubygems is not allowing pushes:
+
+    $ git clone https://github.com/JoshCheek/seeing_is_believing/
+    $ cd seeing_is_believing
+    $ gem build seeing_is_believing.gemspec
+    $ gem install seeing_is_believing-0.0.7.gem
+    $ cd ..
+    $ rm -rf "./seeing_is_believing"
+
+When Rubygems gets back up:
+
     $ gem install seeing_is_believing
 
 Or if you haven't fixed your gem home, and you aren't using any version managers:
 
     $ sudo gem install seeing_is_believing
 
+Hook it into TextMate
+=====================
+
+Go to the bundle editor, create this new command in the Ruby bundle:
+
+    "${TM_RUBY}" -r seeing_is_believing/binary -e '
+      SeeingIsBelieving::Binary.new(ARGV, $stdin, $stdout, $stderr).call
+    '  $TM_FILEPATH 2>/dev/null
+
+It should look like this:
+
+![textmate-integration][textmate-integration]
+
 Known Issues
 ============
 
-* 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
+* `BEGIN/END` breaks things and I probably won't take the time to fix it, becuase it's nontrivial, but there is currently a cuke for it
+* Heredocs aren't recorded. It might actually be possible if the ExpressionList were to get smarter
 
 License
 =======
@@ -97,3 +121,5 @@ License
 
 
 [inventing_on_principle]: http://vimeo.com/36579366
+[textmate-integration]:   https://raw.github.com/JoshCheek/seeing_is_believing/master/textmate-integration.png
+[video]:                  http://vimeo.com/58766950

data/bin/seeing_is_believing

@@ -2,7 +2,5 @@
 
 $LOAD_PATH.unshift File.expand_path '../../lib', __FILE__
 
-require 'open3'
 require 'seeing_is_believing/binary'
-
 exit SeeingIsBelieving::Binary.new(ARGV, $stdin, $stdout, $stderr).exitstatus

data/features/binary_examples.feature

@@ -21,10 +21,20 @@ Feature: Running the binary successfully
     meth "12"
     meth "34"
 
+    =begin
+    I don't ever actually write
+      comments like this
+    =end
+
     # multilinezzz
     "a
      b
      c"
+
+    # don't record heredocs b/c they're just too fucking different
+    <<HERE
+    is a doc
+    HERE
     """
     When I run "seeing_is_believing basic_functionality.rb"
     Then stderr is empty
@@ -43,10 +53,20 @@ Feature: Running the binary successfully
     meth "12"       # => "12"
     meth "34"       # => "34"
 
+    =begin
+    I don't ever actually write
+      comments like this
+    =end
+
     # multilinezzz
     "a
      b
      c"             # => "a\n b\n c"
+
+    # don't record heredocs b/c they're just too fucking different
+    <<HERE
+    is a doc
+    HERE
     """
 
   Scenario: Passing previous output back into input
@@ -170,6 +190,26 @@ Feature: Running the binary successfully
     # >> 2
     """
 
-  Scenario: Requiring other files
-  Scenario: Evaluating a file that requires other files, from a different directory
+  Scenario: Reading from stdin
+    Given I have the stdin content "hi!"
+    And the file "reads_from_stdin.rb":
+    """
+    puts "You said: #{gets}"
+    """
+    When I run "seeing_is_believing reads_from_stdin.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    puts "You said: #{gets}"  # => nil
+
+    # >> You said: hi!
+    """
+
   Scenario: Passing the file on stdin
+    Given I have the stdin content "1 + 1"
+    When I run "seeing_is_believing"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is "1 + 1  # => 2"
+

data/features/step_definitions/steps.rb

@@ -2,8 +2,12 @@ Given 'the file "$filename":' do |filename, body|
   CommandLineHelpers.write_file filename, body
 end
 
+Given 'I have the stdin content "$content"' do |content|
+  @stdin_data = content
+end
+
 When 'I run "$command"' do |command|
-  @last_executed = CommandLineHelpers.execute command
+  @last_executed = CommandLineHelpers.execute command, @stdin_data
 end
 
 Then /^(stderr|stdout) is:$/ do |stream_name, output|

data/features/support/env.rb

@@ -18,10 +18,11 @@ module CommandLineHelpers
     end
   end
 
-  def execute(command)
+  def execute(command, stdin_data=nil)
+    stdin_data ||= ''
     in_proving_grounds do
       bin_in_path = {'PATH' => "#{bin_dir}:#{ENV['PATH']}"}
-      Invocation.new *Open3.capture3(bin_in_path, command)
+      Invocation.new *Open3.capture3(bin_in_path, command, stdin_data: stdin_data)
     end
   end
 

data/lib/seeing_is_believing.rb

@@ -14,6 +14,7 @@ class SeeingIsBelieving
     @string   = string_or_stream
     @stream   = to_stream string_or_stream
     @filename = options[:filename]
+    @stdin    = to_stream options.fetch(:stdin, '')
   end
 
   def call
@@ -35,7 +36,7 @@ class SeeingIsBelieving
                                             on_complete: lambda { |line, children, completions, line_number|
                                               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)
+                                              if do_not_record? expression
                                                 expression + "\n"
                                               else
                                                 record_yahself(expression, line_number) + "\n"
@@ -65,7 +66,7 @@ class SeeingIsBelieving
   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|
+      EvaluateByMovingFiles.new(program, filename, input_stream: @stdin).call.tap do |result|
         result.track_line_number min_line_number
         result.track_line_number max_line_number
       end
@@ -100,4 +101,11 @@ class SeeingIsBelieving
   def the_rest_of_the_stream
     get_next_line << "\n" << stream.read
   end
+
+  def do_not_record?(code)
+    code =~ BLANK_REGEX                     ||
+      SyntaxAnalyzer.ends_in_comment?(code) ||
+      SyntaxAnalyzer.will_return?(code)     ||
+      SyntaxAnalyzer.here_doc?(code)
+  end
 end

data/lib/seeing_is_believing/binary.rb

@@ -15,27 +15,10 @@ class SeeingIsBelieving
       return if @already_called
       @already_called = true
 
-      unless File.exist? filename
-        @exitstatus = 1
-        stderr.puts "#{filename} does not exist!"
-        return
-      end
-
-      out, err, syntax_status = Open3.capture3('ruby', '-c', filename)
-      unless syntax_status.success?
-        @exitstatus = 1
-        stderr.puts err
-        return
-      end
-
-      believer = SeeingIsBelieving::PrintResultsNextToLines.new File.read(filename), filename
-      stdout.puts believer.call
-      if believer.has_exception?
-        stderr.puts believer.exception.message
-        @exitstatus = 1
-      else
-        @exitstatus = 0
-      end
+      file_exists_or_is_on_stdin &&
+        syntax_is_valid          &&
+        print_program            &&
+        display_exceptions
     end
 
     def exitstatus
@@ -45,8 +28,52 @@ class SeeingIsBelieving
 
     private
 
+    def on_stdin?
+      argv.empty?
+    end
+
     def filename
       argv.first
     end
+
+    def believer
+      @believer ||= begin
+        if on_stdin?
+          PrintResultsNextToLines.new stdin.read, ''
+        else
+          PrintResultsNextToLines.new File.read(filename), stdin, filename
+        end
+      end
+    end
+
+    def file_exists_or_is_on_stdin
+      return true if on_stdin? || File.exist?(filename)
+      @exitstatus = 1
+      stderr.puts "#{filename} does not exist!"
+      false
+    end
+
+    def syntax_is_valid
+      return true if on_stdin? # <-- should probably check stdin too
+      out, err, syntax_status = Open3.capture3('ruby', '-c', filename)
+      return true if syntax_status.success?
+      @exitstatus = 1
+      stderr.puts err
+      false
+    end
+
+    def print_program
+      stdout.puts believer.call
+      true
+    end
+
+    def display_exceptions
+      if believer.has_exception?
+        stderr.puts believer.exception.message
+        @exitstatus = 1
+      else
+        @exitstatus = 0
+      end
+    end
   end
 end

data/lib/seeing_is_believing/error.rb

@@ -3,5 +3,12 @@ class SeeingIsBelieving
   # can catch any error generated by this lib
   SeeingIsBelievingError = Class.new StandardError
 
-  TempFileAlreadyExists = Class.new SeeingIsBelievingError
+  class TempFileAlreadyExists < SeeingIsBelievingError
+    def initialize(from_filename, temp_filename)
+      super "Trying to back up #{from_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
+  end
 end

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -12,6 +12,7 @@
 # when it sees this.
 
 require 'open3'
+require 'stringio'
 require 'fileutils'
 require 'seeing_is_believing/error'
 require 'seeing_is_believing/result'
@@ -19,12 +20,13 @@ require 'seeing_is_believing/hard_core_ensure'
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
-    attr_accessor :program, :filename, :error_stream
+    attr_accessor :program, :filename, :error_stream, :input_stream
 
     def initialize(program, filename, options={})
       self.program      = program
       self.filename     = File.expand_path(filename)
-      self.error_stream = options.fetch :error_stream, $stderr
+      self.error_stream = options.fetch :error_stream, $stderr # hmm, not really liking the global here
+      self.input_stream = options.fetch :input_stream, StringIO.new('')
     end
 
     def call
@@ -61,11 +63,7 @@ class SeeingIsBelieving
     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."
+      raise TempFileAlreadyExists.new(filename, temp_filename) if File.exist? temp_filename
     end
 
     def move_file_to_tempfile
@@ -84,13 +82,21 @@ class SeeingIsBelieving
     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
-      )
+      Open3.popen3 '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 do |i, o, e, t|
+        out_reader = Thread.new { o.read }
+        err_reader = Thread.new { e.read }
+        Thread.new do
+          input_stream.each_char { |char| i.write char }
+          i.close
+        end
+        self.stdout     = out_reader.value
+        self.stderr     = err_reader.value
+        self.exitstatus = t.value
+      end
     end
 
     def fail

data/lib/seeing_is_believing/expression_list.rb

@@ -84,7 +84,7 @@ class SeeingIsBelieving
     def children_will_never_be_valid?(expression)
       analyzer = SyntaxAnalyzer.new(expression)
       analyzer.parse
-      analyzer.unclosed_string? || analyzer.unclosed_regexp?
+      analyzer.unclosed_string? || analyzer.unclosed_regexp? || SyntaxAnalyzer.unclosed_comment?(expression)
     end
   end
 end

data/lib/seeing_is_believing/print_results_next_to_lines.rb

@@ -10,9 +10,10 @@ class SeeingIsBelieving
     EXCEPTION_PREFIX = '# ~>'
        RESULT_PREFIX = '# =>'
 
-    def initialize(body, filename=nil)
+    def initialize(body, stdin, filename=nil)
       self.body     = remove_previous_output_from body
       self.filename = filename
+      self.stdin    = stdin
     end
 
     def new_body
@@ -26,15 +27,15 @@ class SeeingIsBelieving
       add_stdout
       add_stderr
       add_data_segment
-      new_body
+      return new_body
     end
 
     private
 
-    attr_accessor :body, :filename, :file_result
+    attr_accessor :body, :filename, :file_result, :stdin
 
     def evaluate_program
-      self.file_result = SeeingIsBelieving.new(body, filename: filename).call
+      self.file_result = SeeingIsBelieving.new(body, filename: filename, stdin: stdin).call
     end
 
     def inherit_exception
@@ -58,11 +59,12 @@ class SeeingIsBelieving
       line.chomp == '__END__'
     end
 
-    # max line length of the body + 2 spaces for padding
+    # max line length of the body (exempting coments) + 2 spaces for padding
     def line_length
       @line_length ||= 2 + body.each_line
                                .map(&:chomp)
                                .take_while { |line| not start_of_data_segment? line }
+                               .select { |line| not (line == "=begin") .. (line == "=end") }
                                .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
                                .map(&:length)
                                .max
@@ -70,8 +72,8 @@ class SeeingIsBelieving
 
     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,        '')
+            .gsub(/\n?(^#{STDOUT_PREFIX}[^\n]*\r?\n?)+/m,          '')
+            .gsub(/\n?(^#{STDERR_PREFIX}[^\n]*\r?\n?)+/m,          '')
     end
 
     def add_stdout

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -46,7 +46,13 @@ class SeeingIsBelieving
     end
 
     def self.valid_ruby?(code)
-      parsed(code).valid_ruby?
+      parsed(code).valid_ruby? && begin_and_end_comments_are_complete?(code)
+    end
+
+    def self.begin_and_end_comments_are_complete?(code)
+      code.scan(/^=(?:begin|end)$/)
+          .each_slice(2)
+          .all? { |b, e| b == '=begin' && e == '=end' }
     end
 
     def valid_ruby?
@@ -108,7 +114,11 @@ class SeeingIsBelieving
     # COMMENTS
 
     def self.ends_in_comment?(code)
-      parsed(code.lines.to_a.last.to_s).has_comment?
+      code =~ /^=end\Z/ || parsed(code.lines.to_a.last.to_s).has_comment?
+    end
+
+    def self.unclosed_comment?(code)
+      !begin_and_end_comments_are_complete?(code)
     end
 
     def has_comment?
@@ -127,5 +137,37 @@ class SeeingIsBelieving
     def self.will_return?(code)
       /(^|\s)return.*?\Z$/ =~ code
     end
+
+    # HERE DOCS
+
+    def self.here_doc?(code)
+      instance = parsed code
+      instance.has_heredoc? && code.scan("\n").size.next <= instance.here_doc_last_line_number
+    end
+
+    def heredocs
+      @heredocs ||= []
+    end
+
+    def on_heredoc_beg(beginning)
+      heredocs << [beginning]
+      super
+    end
+
+    def on_heredoc_end(ending)
+      result      = super
+      line_number = result.last.first
+      doc = heredocs.find { |(beginning)| beginning.include? ending.strip }
+      doc << ending << line_number
+      result
+    end
+
+    def has_heredoc?
+      heredocs.any?
+    end
+
+    def here_doc_last_line_number
+      heredocs.last.last
+    end
   end
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.5'
+  VERSION = '0.0.7'
 end

data/seeing_is_believing.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.add_development_dependency "rake",     "~> 10.0.3"
   s.add_development_dependency "rspec",    "~> 2.12.0"
   s.add_development_dependency "cucumber", "~> 1.2.1"
   s.add_development_dependency "ichannel", "~> 5.1.1"

data/spec/evaluate_by_moving_files_spec.rb

@@ -4,8 +4,8 @@ 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)
+  def invoke(program, options={})
+    evaluator = described_class.new(program, filename, options)
     FileUtils.rm_f evaluator.temp_filename
     evaluator.call
   end
@@ -65,4 +65,11 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
     expect { evaluator.call }.to raise_error
     stderr.string.should include "It blew up"
   end
+
+  it "doesn't block waiting for io on stdin" do
+    reader, writer = IO.pipe
+    thread = Thread.new { invoke '1', input_stream: reader }
+    sleep 0.05
+    thread.should_not be_alive
+  end
 end

data/spec/expression_list_spec.rb

@@ -125,6 +125,27 @@ describe SeeingIsBelieving::ExpressionList do
     block_invocations.should == 1
   end
 
+  example "example: =begin/=end comments" do
+    block_invocations = 0
+    call ['=begin', '1', '=end'] do |*expressions, line_number|
+      expressions.join('').should == "=begin1=end"
+      line_number.should == 3
+      block_invocations += 1
+    end
+    block_invocations.should == 1
+  end
+
+  example "example: heredoc" do
+    pending 'Not sure how to do this, for now just catch it at a higher level' do
+      result = call ['strings = [<<A, <<-B]', '1', 'A', '2', ' B'] do |*expressions, line_number|
+        line_number.should == 1
+        expressions.should == ['strings = [<<A, <<B]']
+        'zomg!'
+      end
+      result.should == "zomg!\n1\nA\n2\n B"
+    end
+  end
+
   example "example: smoke test debug option" do
     stream = StringIO.new
     call(%w[a+ b], debug: true, debug_stream: stream) { |*expressions, _| expressions.join("\n") }

data/spec/seeing_is_believing_spec.rb

@@ -2,8 +2,8 @@ require 'seeing_is_believing'
 require 'stringio'
 
 describe SeeingIsBelieving do
-  def invoke(input)
-    described_class.new(input).call
+  def invoke(input, options={})
+    described_class.new(input, options).call
   end
 
   def values_for(input)
@@ -104,6 +104,15 @@ describe SeeingIsBelieving do
                 3 # at end of program").should == [['1'], [], []]
   end
 
+  it "does not record expressions that are here docs (only really b/c it's not smart enough)" do
+    values_for("<<A\n1\nA").should be_all &:empty?
+    values_for(" <<A\n1\nA").should be_all &:empty?
+    values_for("<<-A\n1\n A").should be_all &:empty?
+    values_for(" <<-A\n1\n A").should be_all &:empty?
+    values_for("s=<<-A\n1\n A").should be_all &:empty?
+    values_for("def meth\n<<-A\n1\nA\nend").should == [[], [], [], [], ['nil']]
+  end
+
   it 'has no output for empty lines' do
     values_for('').should == [[]]
     values_for('  ').should == [[]]
@@ -185,15 +194,16 @@ describe SeeingIsBelieving do
   it 'can be told to run as a given file (in a given dir/with a given filename)' do
     filename = File.join proving_grounds_dir, 'mah_file.rb'
     FileUtils.rm_f filename
-    result   = described_class.new('print File.expand_path __FILE__', filename: filename).call
+    result   = invoke 'print File.expand_path __FILE__', filename: filename
     result.stdout.should == filename
   end
 
+  # this can be refactored to use invoke
   specify 'cwd is the directory of the file' do
     filename = File.join proving_grounds_dir, 'mah_file.rb'
     FileUtils.rm_f filename
-    result   = described_class.new('print File.expand_path __FILE__', filename: filename).call
-    result   = described_class.new('print File.expand_path(Dir.pwd)', filename: filename).call
+    result   = invoke 'print File.expand_path __FILE__', filename: filename
+    result   = invoke 'print File.expand_path(Dir.pwd)', filename: filename
     result.stdout.should == proving_grounds_dir
   end
 
@@ -204,4 +214,16 @@ describe SeeingIsBelieving do
   it 'raises a SyntaxError when the whole program is invalid' do
     expect { invoke '"' }.to raise_error SyntaxError
   end
+
+  it 'can be given a stdin stream' do
+    invoke('$stdin.read', stdin: StringIO.new("input"))[1].should == ['"input"']
+  end
+
+  it 'can be given a stdin string' do
+    invoke('$stdin.read', stdin: "input")[1].should == ['"input"']
+  end
+
+  it 'defaults the stdin stream to an empty string' do
+    invoke('$stdin.read')[1].should == ['""']
+  end
 end

data/spec/syntax_analyzer_spec.rb

@@ -5,21 +5,61 @@ describe SeeingIsBelieving::SyntaxAnalyzer do
     is_valid = lambda { |code| described_class.valid_ruby? code }
     is_valid['1+2'].should be_true
     is_valid['+'].should be_false
+    is_valid["=begin\n1\n=end"].should be_true
 
     # due to what are possibly bugs in Ripper
     # these don't raise any errors, so have to check them explicitly
     is_valid["'"].should be_false
     is_valid["/"].should be_false
+    is_valid["=begin"].should be_false
+    is_valid[" =begin"].should be_false
+    is_valid[" = begin"].should be_false
+    is_valid["=begin\n1"].should be_false
+    is_valid["=begin\n1\n=end\n=begin"].should be_false
+    is_valid["=begin\n1\n=end\n=end"].should be_false
+  end
+
+  it 'knows if the expression is a heredoc' do
+    is_here_doc = lambda { |code| described_class.here_doc? code }
+    is_here_doc["<<A\nA"].should be_true
+    is_here_doc["a=<<A\nabc\nA"].should be_true
+    is_here_doc["meth(<<A)\nabc\nA"].should be_true
+    is_here_doc["meth(<<A)\nabc\nA"].should be_true
+    is_here_doc["meth(<<-A)\n abc\n A"].should be_true
+    is_here_doc["meth(<<-\"a b\")\n abc\n a b"].should be_true
+    is_here_doc["meth(<<-\"a b\", <<something)\n 1\n a b\n2\nsomething"].should be_true
+
+    is_here_doc["a=<<A\nabc\nA\na"].should be_false
+    is_here_doc["def meth\nwhateva(<<A)\nabc\nA\nend"].should be_false
+    is_here_doc["a << b\nb"].should be_false
+    is_here_doc["a<<b\nb"].should be_false
   end
 
   it 'knows if the last line is a comment' do
     is_comment = lambda { |code| described_class.ends_in_comment? code }
+
+    # true
     is_comment['# whatev'].should be_true
     is_comment['a # whatev'].should be_true
     is_comment["a \n b # whatev"].should be_true
+    is_comment["=begin\n1\n=end"].should be_true
+
+    # false
     is_comment['a'].should be_false
     is_comment["a # whatev \n b"].should be_false
     is_comment[""].should be_false
+    is_comment["=begin\n=end\n\n =end"].should be_false
+  end
+
+  it 'knows if it contains an unclosed comment' do
+    unclosed_comment = lambda { |code| described_class.unclosed_comment? code }
+    unclosed_comment["=begin"].should be_true
+    unclosed_comment["=begin\n"].should be_true
+    unclosed_comment["=begin\n1"].should be_true
+    unclosed_comment["1\n=begin\n1\n"].should be_true
+    unclosed_comment["1\n=begin\n1\n =end"].should be_true
+    unclosed_comment["1\n=begin\n1\n=end"].should be_false
+    unclosed_comment[" =begin"].should be_false
   end
 
   # probably don't really need this many tests, but I'm unfamiliar with how thorough Ripper is

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-29 00:00:00.000000000 Z
+date: 2013-02-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70192747454180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: *70192747454180
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70333793492220 !ruby/object:Gem::Requirement
+  requirement: &70192747453400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +32,10 @@ dependencies:
         version: 2.12.0
   type: :development
   prerelease: false
-  version_requirements: *70333793492220
+  version_requirements: *70192747453400
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70333793491440 !ruby/object:Gem::Requirement
+  requirement: &70192747452720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +43,10 @@ dependencies:
         version: 1.2.1
   type: :development
   prerelease: false
-  version_requirements: *70333793491440
+  version_requirements: *70192747452720
 - !ruby/object:Gem::Dependency
   name: ichannel
-  requirement: &70333793490760 !ruby/object:Gem::Requirement
+  requirement: &70192747452260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +54,7 @@ dependencies:
         version: 5.1.1
   type: :development
   prerelease: false
-  version_requirements: *70333793490760
+  version_requirements: *70192747452260
 description: Records the results of every line of code in your file (intended to be
   like xmpfilter), inspired by Bret Victor's JavaScript example in his talk "Inventing
   on Principle"
@@ -83,6 +94,7 @@ files:
 - spec/hard_core_ensure_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/syntax_analyzer_spec.rb
+- textmate-integration.png
 homepage: https://github.com/JoshCheek/seeing_is_believing
 licenses: []
 post_install_message: