ripl-multi_line 0.2.4 → 0.3.0

data/.gemspec

@@ -11,7 +11,11 @@ Gem::Specification.new do |s|
   s.summary = "A ripl plugin for multi-line eval."
   s.description =  "This ripl plugin allows you to evaluate multiple lines of Ruby code."
   s.required_rubygems_version = ">= 1.3.6"
-  s.add_dependency 'ripl', '>= 0.3.2'
+  s.add_dependency 'ripl', '>= 0.3.6'
+  s.add_development_dependency 'bacon', '>= 1.1.0'
+  s.add_development_dependency 'bacon-bits'
+  s.add_development_dependency 'bacon-rr'
+  s.add_development_dependency 'rr'
   s.files = Dir.glob(%w[{lib,test}/**/*.rb bin/* [A-Z]*.{txt,rdoc} ext/**/*.{rb,c} **/deps.rip]) + %w{Rakefile .gemspec}
   s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
   s.license = 'MIT'

data/CHANGELOG.rdoc

@@ -1,3 +1,13 @@
+== 0.3.0
+* comes with five different multi-line implementations: live_error, error_check, irb, ripper and ruby_parser
+  * can be changed with config[:multi_line_engine], default is :live_error
+* add :multi_line_history option (default: compact), based on https://gist.github.com/939846
+* support =begin...=end comments
+* add Shell#multiline? method to check if input should be handled as multi-line input
+  * separate Ruby-specific multi-line stuff from general implementation
+* add some basic tests
+* force multi-line with ; after input
+
 == 0.2.4
 * fix 1.8 warning
 
@@ -13,7 +23,7 @@
 
 == 0.2.0
 * store buffer in an array instead of a string
-* added ctrl+c to remove last line in multi-line situation
+* added ctrl+c to remove last line in multi-line situations
 
 == 0.1.4
 * be compatible with 0.2.4 (undo monkey patch)

data/README.rdoc

@@ -4,25 +4,59 @@ This {ripl}[https://github.com/cldwalker/ripl] plugin allows you to evaluate mul
 == Install
 Install the gem with
 
- gem install ripl-multi_line
+  gem install ripl-multi_line
 
 == Usage
-
 Add the following line to your <tt>~/.riplrc</tt>
 
   require 'ripl/multi_line'
 
+<b>Hint:</b> In multi-line situations, you can press <tt>ctrl+c</tt> and the last line will be removed.
+
+== Options
 You can customize your multi-line prompt with the <tt>:multi_line_prompt</tt> option. For example, put this into your <tt>~/.riplrc</tt>:
 
   Ripl.config[:multi_line_prompt] = ' > '
 
-If you are in multi-line situation, you can press <tt>ctrl+c</tt> and the last line will be removed.
+It also takes a proc as value.
+
+Then there is the <tt>:multi_line_history</tt> option. The default value is <tt>:compact</tt> which tries to squeeze your last multi-line block into one line (works best in mri, in about 98% of all cases).
+
+  >> def some_multi_line_block
+  |    42
+  |  end #=> nil
+  # Press <UP>
+  >> def some_multi_line_block; 42; end
+
+Another value is <tt>:block</tt>, which joins the multi-line block with new-lines.
+
+To leave the history untouched, set it to <tt>:plain</tt> or a false value.
 
 == AutoIndent
-There is also an indention plugin available: {ripl-auto_indent}[https://github.com/janlelis/ripl-auto_indent]
+Check out the {ripl-auto_indent}[https://github.com/janlelis/ripl-auto_indent] plugin to get ruby syntax indention.
+
+== MultiLine detection
+To use your own multi-line detection engine, implement your version at <tt>lib/ripl/multi_line/your_correct_detection.rb</tt> in which you overwrite <tt>Shell#multiline?</tt> in a <tt>Ripl::MultiLine</tt> sub-module named <tt>YourCorrectDetection</tt> and set <tt>Ripl.config[:multi_line_engine]</tt> to <tt>:your_correct_detection</tt>. See <tt>lib/ripl/multi_line/*.rb</tt> for examples.
+
+Currently available engines:
+* <tt>:live_error</tt> (<b>default</b>) - Simply evaluate expression, if it throws a multi-line syntax error, fall back to multi-line input mode. Sounds scary, but works pretty well in practice.
+* <tt>:error_check</tt> - Same principle as :live_error, but don't do it live
+* <tt>:ripper</tt> - Analyze input with Ripper (comes with 1.9, but there is also a 1.8 gem).
+* <tt>:ruby_parser</tt> - Use ruby_parser gem (1.8 only)
+* <tt>:irb</tt> - You left irb, but you are still used to its multi-line behaviour? Use irb's RubyLex!
+
+None of the above solutions is perfect, so... maybe it's time to roll your own ;)
+
+== Troubleshooting
+<i>Problem:</i> "I've required <tt>ripl-multi_line</tt>, but it doesn't work"
+
+<i>Answer:</i> This is probably caused by a plugin, which overwrites <tt>:before_loop</tt>, but does not call <tt>super</tt> (or you are using ripl-profiles older than 0.2.0). You can manually work around this issue with this snippet (but you should fix the general problem):
+
+  require 'ripl/multi_line/live_error.rb'
+  Ripl::MultiLine.engine = Ripl::MultiLine::LiveError
+  Ripl::Shell.include Ripl::MultiLine.engine
 
-== Planned for version 0.3.0
-* Tests :)
-* Replaceable check if syntax is valid (then, the plugin can be used for other languages than Ruby)
+== Credits
+Contributions & influences by cldwalker and godfat.
 
 J-_-L

data/Rakefile

@@ -6,7 +6,7 @@ def gemspec
 end
 
 desc "Build the gem"
-task :gem=>:gemspec do
+task :gem => :gemspec do
   sh "gem build .gemspec"
   FileUtils.mkdir_p 'pkg'
   FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
@@ -14,7 +14,7 @@ end
 
 desc "Install the gem locally"
 task :install => :gem do
-  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version}}
+  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version} --no-rdoc --no-ri}
 end
 
 desc "Generate the gemspec"

data/lib/ripl/multi_line.rb

@@ -2,27 +2,27 @@ require 'ripl'
 
 module Ripl
   module MultiLine
-    VERSION = '0.2.4'
-    ERROR_REGEXP = /#{
-      [ %q%unexpected \$end%,
-        %q%unterminated [a-z]+ meets end of file%,
-        # rubinius
-        %q%expecting '\\n' or ';'%,
-        %q%missing 'end'%,
-        %q%expecting '\}'%,
-        # jruby
-        %q%syntax error, unexpected end-of-file%,
-      ]*'|' }/
+    VERSION = '0.3.0'
+
+    class << self
+      attr_accessor :engine
+    end
 
     def before_loop
+      @buffer = @buffer_info = nil
+      # include CamelCased implementation
+      require File.join( 'ripl', 'multi_line', config[:multi_line_engine].to_s )
+      Ripl::MultiLine.engine = Ripl::MultiLine.const_get(
+        config[:multi_line_engine].to_s.gsub(/(^|_)(\w)/){ $2.capitalize }
+      )
+      Ripl::Shell.include Ripl::MultiLine.engine
       super
-      @buffer = nil
     end
 
     def prompt
       if @buffer
         config[:multi_line_prompt].respond_to?(:call) ? 
-            config[:multi_line_prompt].call :
+            config[:multi_line_prompt].call( *@buffer_info[-1] ) :
             config[:multi_line_prompt]
       else
         super
@@ -35,49 +35,87 @@ module Ripl
     def loop_once
       catch(:multiline) do
         super
-        @buffer = nil
+        if config[:multi_line_history] && @buffer && @input
+          (@buffer.size + 1).times{ history.pop }
+
+          if config[:multi_line_history] == :compact
+            history_entry = ''
+            @buffer.zip(@buffer_info){ |str, type|
+              history_entry << str
+              history_entry << case
+              when !type.is_a?(Array)
+                "\n" # fallback to :block for unsure
+              when type[0] == :statement
+                '; '
+              when type[0] == :literal && ( type[1] == :string || type[1] == :regexp )
+                '\n'
+              else
+                ''
+              end
+            }
+            history_entry << @input
+            history << history_entry
+          else # true or :block
+            history << (@buffer << @input).join("\n")
+          end
+        end
+
+        @buffer = @buffer_info = nil
       end
     end
 
-    def print_eval_error(e)
-      if e.is_a?(SyntaxError) && e.message =~ ERROR_REGEXP
-        @buffer ||= []
-        @buffer << @input
-        throw :multiline
-      else
-        super
-      end
+    # This method is overwritten by a multi-line implementation in lib/multi_line/*.rb
+    #   It should return a true value for a string that is unfinished and a false one
+    #    for complete expressions, which should get evaluated.
+    #   It's also possible (and encouraged) to return an array of symbols describing
+    #    what's the reason for continuing the expression (this is used in the :compact
+    #    history and gets passed to the prompt proc.
+    def multiline?(eval_string)
+      false
+    end
+
+    def handle_multiline(type = [:statement]) # MAYBE: add second arg for specific information
+      @buffer ||= []
+      @buffer_info ||= []
+      @buffer << @input
+      @buffer_info << type
+      throw :multiline
     end
   
     def loop_eval(input)
-      if @buffer
-        super @buffer*"\n" + "\n" + input
-      else
-        super input
+      eval_string = if @buffer then @buffer*"\n" + "\n" + input else input end
+      if type = multiline?(eval_string)
+        handle_multiline(type)
       end
+      super eval_string
     end
 
     # remove last line from buffer
-    # TODO: nicer interface (rewriting?)
+    # MAYBE: terminal rewriting
     def handle_interrupt
       if @buffer
-        @buffer.pop
+        @buffer.pop; @buffer_info.pop; history.pop
         if @buffer.empty?
-          @buffer = nil
+          @buffer = @buffer_info = nil
+          print '[buffer empty]'
           return super
         else
-          puts "[previous line removed]"
+          puts "[previous line removed|#{@buffer.size}]"
           throw :multiline
         end
       else
         super
       end
     end
+
   end
 end
 
-Ripl::Shell.include Ripl::MultiLine
-Ripl.config[:multi_line_prompt] ||= proc do # you can also use a plain string here
+Ripl::Shell.include Ripl::MultiLine              # implementation gets included in before_loop
+Ripl.config[:multi_line_engine]  ||= :live_error # not satisfied? try :ripper, :irb or implement your own
+Ripl.config[:multi_line_history] ||= :compact    # possible other values: :block, :blank
+
+Ripl.config[:multi_line_prompt]  ||= proc do     # you can also use a plain string here
   '|' + ' '*(Ripl.shell.instance_variable_get(:@prompt).size-1) # '|  '
 end
 

data/lib/ripl/multi_line/error_check.rb

@@ -0,0 +1,31 @@
+require 'ripl'
+
+Ripl.config[:multi_line_engine] ||= :error_check
+require 'ripl/multi_line'
+require 'ripl/multi_line/live_error'
+
+# # # #
+# This multi-line implementation uses IRB's RubyLex parser
+#   works on:         1.9  1.8  jruby  rbx
+#   analyze features: see live_error.rb
+#   known issues:     see live_error.rb
+module Ripl::MultiLine::ErrorCheck
+  VERSION = '0.1.0'
+
+  ruby_engine = defined?(RUBY_ENGINE) && RUBY_ENGINE.downcase.to_sym
+  ruby_engine = :ruby if !Ripl::MultiLine::LiveError::ERROR_MESSAGES.keys.include?(ruby_engine)
+
+  define_method(:multiline?) do |string|
+    break [:forced] if string =~ /;\s*\Z/ # force multi line with ;
+
+    begin
+      eval "if nil; #{string}; end"
+    rescue SyntaxError => e
+      Ripl::MultiLine::LiveError::ERROR_MESSAGES[ruby_engine].each{ |type, message|
+        break type if message === e.message
+      }
+    end
+  end
+end
+
+# J-_-L

data/lib/ripl/multi_line/irb.rb

@@ -0,0 +1,59 @@
+require 'ripl'
+require 'irb/ruby-lex'
+require 'stringio'
+
+Ripl.config[:multi_line_engine] ||= :irb
+require 'ripl/multi_line'
+
+# # # #
+# This multi-line implementation uses IRB's RubyLex parser
+#   works on:         1.9  1.8  jruby  rbx
+#   analyze features: none
+module Ripl::MultiLine::Irb
+  VERSION = '0.1.0'
+
+  class << self
+    attr_reader :scanner
+  end
+ 
+  # create scanner and patch it to our needs
+  @scanner = RubyLex.new
+
+  def @scanner.multiline?
+    initialize_input
+    @continue = false
+    @found_eof = false
+
+    while line = lex
+      @line << line
+      @continue = false
+    end
+      
+    !!( !@found_eof or @ltype or @continue or @indent > 0 )
+  end
+
+  def @scanner.lex
+    until (((tk = token).kind_of?(RubyLex::TkNL) || tk.kind_of?(RubyLex::TkEND_OF_SCRIPT)) &&
+	     !@continue or
+	     tk.nil?)
+      #p tk
+      #p @lex_state
+      #p self
+    end
+    @found_eof = true if tk.kind_of?(RubyLex::TkEND_OF_SCRIPT)
+    line = get_readed
+    #      print self.inspect
+    if line == "" and tk.kind_of?(RubyLex::TkEND_OF_SCRIPT) || tk.nil?
+      nil
+    else
+      line
+    end
+  end
+
+  def multiline?(string)
+    Ripl::MultiLine::Irb.scanner.set_input StringIO.new(string + "\0")
+    Ripl::MultiLine::Irb.scanner.multiline?
+  end
+end
+
+# J-_-L

data/lib/ripl/multi_line/live_error.rb

@@ -0,0 +1,73 @@
+require 'ripl'
+
+Ripl.config[:multi_line_engine] ||= :live_error
+require 'ripl/multi_line'
+
+# # # #
+# This multi-line implementation uses IRB's RubyLex parser
+#   works on:         1.9  1.8  jruby  rbx
+#   analyze features: [:literal, :string]
+#                     [:literal, :regexp]
+#                     [:literal, :array]   (mri only)
+#                     [:literal, :hash]    (mri only)
+#                     [:statement]
+#                     [:forced]
+#   notes:            rbx support buggy (depends on rubinius error messages)
+module Ripl::MultiLine::LiveError
+  VERSION = "0.1.0"
+
+  ERROR_MESSAGES = {
+    :ruby => [
+      [[:literal, :string], /unterminated string meets end of file/],
+      [[:literal, :regexp], /unterminated regexp meets end of file/],
+      [[:literal, :array],  /syntax error, unexpected \$end, expecting '\]'/],
+      [[:literal, :hash],   /syntax error, unexpected \$end, expecting '\}'/], # does not work for ranges or {5=>
+      [[:statement],        /syntax error, unexpected \$end/],
+    ],
+    :jruby => [
+      [[:literal, :string], /unterminated string meets end of file/],
+      [[:literal, :regexp], /unterminated regexp meets end of file/], # array or hash cannot be detected
+      [[:statement],        /syntax error, unexpected end-of-file/],
+    ],
+    :rbx => [
+      [[:literal, :string], /unterminated [a-z]+ meets end of file/], # no extra message for regexes
+      [[:literal],          /expecting '\\n' or ';'/], # TODO: better rbx regexes or rbx bug report
+      [[:literal, :hash],   /expecting '\}'/],
+      # [:literal,          /expecting '\]'/],
+      # [:literal,          /expecting '\)'/],
+      [[:statement],        /syntax error, unexpected \$end/],
+      [[:statement],        /missing 'end'/], # for i in [2,3,4] do;
+    ],
+  }
+  ruby_engine = defined?(RUBY_ENGINE) && RUBY_ENGINE.downcase.to_sym
+  ruby_engine = :ruby if !ERROR_MESSAGES.keys.include?(ruby_engine)
+
+  define_method(:print_eval_error) do |e|
+    if e.is_a? SyntaxError
+      ERROR_MESSAGES[ruby_engine].each{ |type, message|
+        handle_multiline(type) if message === e.message
+      }
+    end
+    super(e)
+  end
+
+  def eval_input(input)
+    if input =~ /;\s*\Z/ # force multi line with ;
+      handle_multiline(:forced)
+    elsif input =~ /^=begin(\s.*)?$/ && !@buffer
+      @ignore_mode = true # MAYBE: change prompt
+    elsif !@ignore_mode
+      super
+    end
+  end
+
+  def print_result(result)
+    if @ignore_mode && @input == '=end'
+      @ignore_mode = false
+    elsif !@ignore_mode
+      super
+    end
+  end
+end
+
+# J-_-L

data/lib/ripl/multi_line/ripper.rb

@@ -0,0 +1,50 @@
+# see https://github.com/cldwalker/ripl-ripper/blob/master/lib/ripl/ripper.rb for a different (standalone) plugin
+require 'ripl'
+require 'ripper'
+
+Ripl.config[:multi_line_engine] ||= :ripper
+require 'ripl/multi_line'
+
+# # # #
+# This multi-line implementation uses IRB's RubyLex parser
+#   works on:         1.9  1.8(gem)
+#   analyze features: [:literal, :string]
+#                     [:literal, :regexp]
+#                     [:literal, :array]   (mri only)
+#                     [:literal, :hash]    (mri only)
+#                     [:statement]
+#                     [:forced]
+#   notes:            statement could also be [
+module Ripl::MultiLine::Ripper
+  VERSION = '0.1.0'
+
+  def multiline?(string)
+    return [:forced] if string =~ /;\s*\Z/
+
+    expr = ::Ripper::SexpBuilder.new(string).parse
+
+    return [:statement] if !expr # not always statements...
+
+    # literals are problematic..
+    last_expr = expr[-1][-1]
+
+    return [:literal, :regexp] if last_expr == [:regexp_literal, [:regexp_new], nil]
+
+    delimiters = %q_(?:[\[<({][\]>)}]|(.)\1)_
+
+    return [:literal, :string] if last_expr == [:string_literal, [:string_content]] &&
+      string !~ /(?:""|''|%q?#{delimiters})\s*\Z/i # empty literal at $
+
+    return [:literal, :string] if last_expr == [:xstring_literal, [:xstring_new]] &&
+      string !~ /(?:``|%x#{delimiters})\s*\Z/i
+
+    return [:literal, :string] if last_expr == [:words_new] &&
+      string !~ /%W#{delimiters}\s*\Z/
+ 
+    return [:literal, :string] if last_expr == [:qwords_new] &&
+      string !~ /%w#{delimiters}\s*\Z/
+  end
+end
+
+
+# J-_-L

data/lib/ripl/multi_line/ruby_parser.rb

@@ -0,0 +1,39 @@
+require 'ripl'
+require 'ruby_parser'
+
+Ripl.config[:multi_line_engine] ||= :ruby_parser
+require 'ripl/multi_line'
+
+# # # #
+# This multi-line implementation uses IRB's RubyLex parser
+#   works on:         1.8
+#   analyze features: [:literal, :string]
+#                     [:literal, :hash]
+#                     [:statement]
+#                     [:forced]
+#   notes:            statement could also be [
+module Ripl::MultiLine::RubyParser
+  VERSION = '0.1.0'
+
+  ERROR_MESSAGES = [
+    [[:literal, :string], /unterminated string meets end of file/],
+    # [[:literal, :regexp], /unterminated regexp meets end of file/],          #-> string
+    # [[:literal, :array],  /syntax error, unexpected \$end, expecting '\]'/], #-> ParseError
+    [[:literal, :hash],   /syntax error, unexpected \$end, expecting '\}'/],   # {45
+  ]
+
+  def multiline?(string)
+    return [:forced] if string =~ /;\s*\Z/ # force multi line with ;
+    ::RubyParser.new.parse(string)
+    false # string was parsable, no multi-line
+  rescue ::Racc::ParseError
+    [:statement]
+  rescue SyntaxError => e
+    ERROR_MESSAGES.each{ |type, message|
+      return type if message === e.message
+    }
+    false # syntax error not multi-line relevant
+  end
+end
+
+# J-_-L

data/test/shell_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Shell" do
+  before { reset_ripl }
+
+  def shell(options={})
+    Ripl.shell(options)
+  end
+
+  describe "multi-line behaviour" do
+    should_eval %| "m" * 2 |
+    should_eval %| "8989" |
+    should_eval %| "zzz" |
+
+    should_not_eval %| "m" *  |
+
+    should_not_eval %| " |
+    should_not_eval %| ' |
+    should_not_eval %| / |
+
+    should_not_eval %| [ |
+    should_not_eval %| { |
+    should_not_eval %| ( |
+
+    should_not_eval %| def hey |
+    should_not_eval %| def hey; 89 |
+    should_not_eval %| begin |
+    should_eval %| for x in [2,3,4];7;end |
+  end
+
+  # TODO add misc real tests for everything
+end

data/test/test_helper.rb

@@ -0,0 +1,83 @@
+require 'bacon'
+require 'bacon/bits'
+require 'rr'
+require 'bacon/rr'
+require 'stringio'
+require 'ripl'
+require 'ripl/multi_line'
+include Ripl
+
+module Helpers
+  def ripl(*args)
+    options = args[-1].is_a?(Hash) ? args.pop : {}
+    mock_riplrc unless options[:riplrc] == false
+    mock(Ripl.shell).loop unless options[:loop] == false
+    capture_stdout { Ripl::Runner.run(args) }
+  end
+
+  def mock_riplrc(&block)
+    mock(Runner).load_rc(Ripl.config[:riplrc], &block)
+  end
+
+  def mock_shell(&block)
+    mock(Shell).create(anything) {|e|
+      shell = Shell.new(e)
+      block ? block.call(shell) : mock(shell).loop
+      shell
+    }
+  end
+
+  def reset_ripl
+    Ripl.instance_eval "@config = @shell = @riplrc = nil"
+  end
+
+  def reset_shell
+    Ripl.send(:remove_const, :Shell)
+    $".delete $".grep(/shell\.rb/)[0]
+    require 'ripl/shell'
+    Ripl::Shell.include Ripl::History
+  end
+
+  def reset_config
+    Ripl.config.merge! :history => '~/.irb_history', :completion => {}
+  end
+
+  def capture_stdout(&block)
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    fake.string
+  end
+
+  def capture_stderr(&block)
+    original_stderr = $stderr
+    $stderr = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stderr = original_stderr
+    end
+    fake.string
+  end
+
+  # multi_line stuff
+  def should_eval(input)
+    it "should evaluate " + input do
+      mock(shell).get_input { input }
+      capture_stderr { capture_stdout { shell.loop_once }.should.not == '' }
+    end
+  end
+
+  def should_not_eval(input)
+    it "should not evaluate " + input do
+      mock(shell).get_input { input }
+      capture_stderr { capture_stdout { shell.loop_once }.should == '' }
+    end
+  end
+end
+
+Bacon::Context.send :include, Helpers

metadata

@@ -2,7 +2,7 @@
 name: ripl-multi_line
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jan Lelis
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-10 00:00:00 +01:00
-default_executable: 
+date: 2011-04-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ripl
@@ -21,9 +20,53 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.3.2
+        version: 0.3.6
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bacon-bits
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bacon-rr
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
 description: This ripl plugin allows you to evaluate multiple lines of Ruby code.
 email: mail@janlelis.de
 executables: []
@@ -35,13 +78,19 @@ extra_rdoc_files:
 - LICENSE.txt
 files: 
 - lib/ripl/multi_line.rb
+- lib/ripl/multi_line/live_error.rb
+- lib/ripl/multi_line/error_check.rb
+- lib/ripl/multi_line/ripper.rb
+- lib/ripl/multi_line/ruby_parser.rb
+- lib/ripl/multi_line/irb.rb
+- test/test_helper.rb
+- test/shell_test.rb
 - LICENSE.txt
 - README.rdoc
 - CHANGELOG.rdoc
 - deps.rip
 - Rakefile
 - .gemspec
-has_rdoc: true
 homepage: http://github.com/janlelis/ripl-multi_line
 licenses: 
 - MIT
@@ -65,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A ripl plugin for multi-line eval.