dietrb 0.1.2 → 0.2.0

data/LICENSE

@@ -0,0 +1,3 @@
+Copyright (c) <2010> Eloy Duran, <eloy.de.enige@gmail.com>
+
+This software is available under the Ruby license.

data/README.rdoc

@@ -0,0 +1,99 @@
+= IRB on a diet, for MacRuby / Ruby 1.9
+
+The goal is to have a small and cleaned up version of IRB. Trimmed down to only
+do the stuff I, and most people I know, actually use.
+
+Trimming down the core code is done mainly by using Ripper, which comes with
+Ruby 1.9, instead of shipping it's own parser etc.
+
+There's still lots to be done, but the ‘basic functionality’ as is now, should
+not grow too much more. For now my things to-do are .irbrc support, completion,
+and investigate what else people really really need. After that it's time to
+polish.
+
+== Differences
+
+* This IRB version specifically targets MacRuby, for now, and allows Cocoa
+  development to be done from the command-line. Dietrb will automatically
+  override the normal runloop to be ran in a thread and start a NSRunLoop on
+  the main thread.
+
+* Dietrb will try to warn about syntax errors as soon as a line is entered and
+  only reset the buffer to the previous line. This means that you don't need to
+  loose any previous work:
+  
+  IRB:
+  
+    irb(main):001:0> class A
+    irb(main):002:1>   def foo
+    irb(main):003:2>     } p :ok
+    irb(main):004:1>   end
+    SyntaxError: compile error
+    (irb):3: syntax error, unexpected '}'
+        } p :ok
+         ^
+    (irb):4: syntax error, unexpected $end, expecting kEND
+    	from (irb):4
+    	from :0
+    irb(main):005:0> A.new.foo
+    NameError: uninitialized constant A
+    	from (irb):5
+    	from :0
+  
+  Dietrb:
+  
+    irb(main):001:0> class A
+    irb(main):002:1>   def foo
+    irb(main):003:2>     } p :ok
+    SyntaxError: compile error
+    (irb):3: syntax error, unexpected '}'
+    irb(main):004:2>     p :ok
+    irb(main):005:2>   end
+    irb(main):006:1> end
+    => nil
+    irb(main):007:0> A.new.foo
+    :ok
+    => :ok
+
+== Play
+
+Normal usage:
+
+  irb(main):001:0> class A
+  irb(main):002:1>   def foo
+  irb(main):003:2>     :ok
+  irb(main):004:2>   end
+  irb(main):005:1> end
+  => nil
+  irb(main):006:0> irb A.new
+  irb(#<#<Class:…>::A:…>):001:0> foo
+  => :ok
+  irb(#<#<Class:…>::A:…>):002:0> quit
+  => nil
+  irb(main):007:0> quit
+
+Or on MacRuby, try:
+
+  irb(main):001:0> win = NSWindow.alloc.initWithContentRect([200, 300, 250, 100],
+  irb(main):002:0>                                styleMask: NSTitledWindowMask|NSResizableWindowMask,
+  irb(main):003:0>                                  backing: NSBackingStoreBuffered,
+  irb(main):004:0>                                    defer: false)
+  => #<NSWindow:0x20023eb00>
+  irb(main):005:0> win.orderFrontRegardless
+  => #<NSWindow:0x20023eb00>
+  irb(main):006:0> win.title = 'Hello World'
+  => "Hello World"
+  irb(main):007:0> bye = NSButton.alloc.initWithFrame([10, 10, 80, 80])
+  => #<NSButton:0x20027f820>
+  irb(main):008:0> win.contentView.addSubview(bye)
+  => #<NSView:0x200210320>
+  irb(main):009:0> bye.bezelStyle = NSThickerSquareBezelStyle
+  => 4
+  irb(main):010:0> bye.title = 'Goodbye!'
+  => "Goodbye!"
+  irb(main):011:0> bye.target = NSApp
+  => #<NSApplication:0x200257fe0>
+  irb(main):012:0> bye.action = 'terminate:'
+  => "terminate:"
+  irb(main):013:0> bye.sound = NSSound.soundNamed('Basso')
+  => #<NSSound:0x200248b20>

data/Rakefile

@@ -1,4 +1,4 @@
-task :default => :spec
+task :default => :run
 
 desc "Run the specs"
 task :spec do
@@ -10,6 +10,11 @@ task :kick do
   sh "kicker -e 'rake spec' lib spec"
 end
 
+desc "Run dietrb with ruby19"
+task :run do
+  sh "ruby19 -Ilib ./bin/dietrb"
+end
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/bin/dietrb

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 
 require 'irb'
-IRB(self)
+irb(self)

data/dietrb.gemspec

@@ -5,29 +5,33 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dietrb}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Eloy Duran"]
-  s.date = %q{2010-02-07}
+  s.date = %q{2010-02-18}
   s.default_executable = %q{dietrb}
   s.description = %q{IRB on a diet, for MacRuby / Ruby 1.9}
   s.email = %q{eloy.de.enige@gmail.com}
   s.executables = ["dietrb"]
   s.extra_rdoc_files = [
-    "README"
+    "LICENSE",
+     "README.rdoc"
   ]
   s.files = [
     ".gitignore",
-     "README",
+     "LICENSE",
+     "README.rdoc",
      "Rakefile",
      "VERSION",
      "bin/dietrb",
      "dietrb.gemspec",
      "lib/irb.rb",
      "lib/irb/context.rb",
+     "lib/irb/ext/completion.rb",
      "lib/irb/ext/macruby.rb",
      "lib/irb/source.rb",
+     "spec/completion_spec.rb",
      "spec/context_spec.rb",
      "spec/irb_spec.rb",
      "spec/source_spec.rb",
@@ -40,7 +44,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{IRB on a diet, for MacRuby / Ruby 1.9}
   s.test_files = [
-    "spec/context_spec.rb",
+    "spec/completion_spec.rb",
+     "spec/context_spec.rb",
      "spec/irb_spec.rb",
      "spec/source_spec.rb",
      "spec/spec_helper.rb"

data/lib/irb/context.rb

@@ -2,6 +2,17 @@ require 'readline'
 
 module IRB
   class Context
+    class << self
+      attr_accessor :current
+      
+      def make_current(context)
+        before, @current = @current, context
+        yield
+      ensure
+        @current = before
+      end
+    end
+    
     attr_reader :object, :binding, :line, :source
     
     def initialize(object)
@@ -11,8 +22,12 @@ module IRB
       clear_buffer
     end
     
+    def __evaluate__(source)
+      eval(source, @binding)
+    end
+    
     def evaluate(source)
-      result = eval("_ = (#{source})", @binding)
+      result = __evaluate__("_ = (#{source})")
       puts format_result(result)
       result
     rescue Exception => e
@@ -24,9 +39,11 @@ module IRB
     end
     
     def run
-      while line = readline
-        continue = process_line(line)
-        break unless continue
+      self.class.make_current(self) do
+        while line = readline
+          continue = process_line(line)
+          break unless continue
+        end
       end
     end
     
@@ -46,7 +63,10 @@ module IRB
       @source << line
       return false if @source.to_s == "quit"
       
-      if @source.valid?
+      if @source.syntax_error?
+        puts format_syntax_error(@source.syntax_error)
+        @source.pop
+      elsif @source.code_block?
         evaluate(@source)
         clear_buffer
       end
@@ -69,6 +89,10 @@ module IRB
       "#{e.class.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
     end
     
+    def format_syntax_error(e)
+      "SyntaxError: compile error\n(irb):#{@line}: #{e}"
+    end
+    
     private
     
     def clear_buffer

data/lib/irb/ext/completion.rb

@@ -0,0 +1,140 @@
+require 'ripper'
+
+module IRB
+  class Completion
+    # Convenience constants for sexp access of Ripper::SexpBuilder.
+    TYPE   = 0
+    VALUE  = 1
+    CALLEE = 3
+    
+    # Returns an array of possible completion results, with the current
+    # IRB::Context.
+    #
+    # This is meant to be used with Readline which takes a completion proc.
+    def self.call(source)
+      new(IRB::Context.current, source).results
+    end
+    
+    attr_reader :context, :source
+    
+    def initialize(context, source)
+      @context, @source = context, source
+    end
+    
+    def evaluate(s)
+      @context.__evaluate__(s)
+    end
+    
+    def local_variables
+      evaluate('local_variables').map(&:to_s)
+    end
+    
+    def instance_methods
+      @context.object.methods.map(&:to_s)
+    end
+    
+    # TODO: test and or fix the fact that we need to get constants from the
+    # singleton class.
+    def constants
+      evaluate('Object.constants + self.class.constants + (class << self; constants; end)').map(&:to_s)
+    end
+    
+    def results
+      source = @source
+      filter = nil
+      
+      # if ends with period, remove it to remove the syntax error it causes
+      call = (source[-1,1] == '.')
+      receiver = source = source[0..-2] if call
+      
+      if sexp = Ripper::SexpBuilder.new(source).parse
+        # [:program, [:stmts_add, [:stmts_new], [x, …]]]
+        #                                        ^
+        root = sexp[1][2]
+        
+        # [:call, [:hash, nil], :".", [:@ident, x, …]]
+        if root[TYPE] == :call
+          call     = true
+          filter   = root[CALLEE][VALUE]
+          receiver = source[0..-(filter.length + 2)]
+          root     = root[VALUE]
+        end
+        
+        if call
+          format_methods(receiver, methods_of_object(root), filter)
+        else
+          match_methods_vars_or_consts_in_scope(root)
+        end.sort
+      end
+    end
+    
+    def match_methods_vars_or_consts_in_scope(symbol)
+      var    = symbol[VALUE]
+      filter = var[VALUE]
+      case var[TYPE]
+      when :@ident
+        local_variables + instance_methods
+      when :@gvar
+        global_variables.map(&:to_s)
+      when :@const
+        if symbol[TYPE] == :top_const_ref
+          filter = "::#{filter}"
+          Object.constants.map { |c| "::#{c}" }
+        else
+          constants
+        end
+      end.grep(/^#{Regexp.quote(filter)}/)
+    end
+    
+    def format_methods(receiver, methods, filter)
+      (filter ? methods.grep(/^#{filter}/) : methods).map { |m| "#{receiver}.#{m}" }
+    end
+    
+    def methods_of_object(root)
+      result = case root[TYPE]
+      # [:unary, :-@, [x, …]]
+      #               ^
+      when :unary                          then return methods_of_object(root[2]) # TODO: do we really need this?
+      when :var_ref, :top_const_ref        then return methods_of_object_in_variable(root)
+      when :array, :words_add, :qwords_add then Array
+      when :@int                           then Fixnum
+      when :@float                         then Float
+      when :hash                           then Hash
+      when :lambda                         then Proc
+      when :dot2, :dot3                    then Range
+      when :regexp_literal                 then Regexp
+      when :string_literal                 then String
+      when :symbol_literal, :dyna_symbol   then Symbol
+      end.instance_methods
+    end
+    
+    def methods_of_object_in_variable(var)
+      subtype, name = var[VALUE][0..1]
+      
+      if var[TYPE] == :top_const_ref
+        if subtype == :@const && Object.constants.include?(name.to_sym)
+          evaluate("::#{name}").methods
+        end
+      else
+        case subtype
+        when :@ident
+          evaluate(name).methods if local_variables.include?(name)
+        when :@gvar
+          eval(name).methods if global_variables.include?(name.to_sym)
+        when :@const
+          evaluate(name).methods if constants.include?(name)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Readline)
+  if Readline.respond_to?("basic_word_break_characters=")
+    # IRB adds a few breaking chars. that would break literals for us:
+    # * String: " and '
+    # * Hash: = and >
+    Readline.basic_word_break_characters= " \t\n`<;|&("
+  end
+  Readline.completion_proc = IRB::Completion
+end

data/lib/irb/source.rb

@@ -14,6 +14,12 @@ module IRB
       @buffer << source.chomp
     end
     
+    # Removes the last line from the buffer and flushes the cached reflection.
+    def pop
+      @reflection = nil
+      @buffer.pop
+    end
+    
     # Returns the accumulated source as a string, joined by newlines.
     def source
       @buffer.join("\n")
@@ -28,8 +34,19 @@ module IRB
     end
     
     # Reflects on the accumulated source to see if it's a valid code block.
-    def valid?
-      reflect.valid?
+    def code_block?
+      reflect.code_block?
+    end
+    
+    # Reflects on the accumulated source to see if it contains a syntax error.
+    def syntax_error?
+      reflect.syntax_error?
+    end
+    
+    # Reflects on the accumulated source and returns the actual syntax error
+    # message if one occurs.
+    def syntax_error
+      reflect.syntax_error
     end
     
     # Returns a Reflector for the accumulated source and caches it.
@@ -37,11 +54,11 @@ module IRB
       @reflection ||= Reflector.new(source)
     end
     
-    class Reflector < Ripper::SexpBuilder
+    class Reflector < Ripper
       def initialize(source)
         super
         @level = 0
-        @valid = !parse.nil?
+        parse
       end
       
       # Returns the code block indentation level.
@@ -53,8 +70,12 @@ module IRB
       #   Reflector.new("class Foo; def foo; end; end").level # => 0
       attr_reader :level
       
+      # Returns the actual syntax error message if one occurs.
+      attr_reader :syntax_error
+      
       # Returns whether or not the source is a valid code block, but does not
-      # take syntax errors into account.
+      # take syntax errors into account. In short, it's a valid code block if
+      # after parsing the level is at zero.
       #
       # For example, this is not a valid full code block:
       #
@@ -63,8 +84,30 @@ module IRB
       # This however is:
       #
       #   def foo; p :ok; end
-      def valid?
-        @valid
+      def code_block?
+        @level == 0
+      end
+      
+      # Returns whether or not the source contains a syntax error. However, it
+      # ignores a syntax error resulting in a code block not ending yet.
+      #
+      # For example, this contains a syntax error:
+      #
+      #   def; foo
+      #
+      # This does not:
+      #
+      #   def foo
+      def syntax_error?
+        !@syntax_error.nil?
+      end
+      
+      UNEXPECTED_END = "syntax error, unexpected $end"
+      
+      def on_parse_error(error) #:nodoc:
+        if code_block? || !error.start_with?(UNEXPECTED_END)
+          @syntax_error = error
+        end
       end
       
       INCREASE_LEVEL_KEYWORDS = %w{ class module def begin if unless case while for do }

data/lib/irb.rb

@@ -7,9 +7,9 @@ end
 
 module Kernel
   # Creates a new IRB::Context with the given +object+ and runs it.
-  def IRB(object)
+  def irb(object)
     IRB::Context.new(object).run
   end
   
-  private :IRB
-end
+  private :irb
+end

data/spec/completion_spec.rb

@@ -0,0 +1,221 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'irb/ext/completion'
+
+module CompletionHelper
+  def complete(str)
+    IRB::Completion.new(@context, str).results
+  end
+  
+  def imethods(klass, receiver = nil)
+    klass.instance_methods.map { |m| [receiver, m.to_s].compact.join('.') }.sort
+  end
+  
+  def methods(object, receiver = nil)
+    object.methods.map { |m| [receiver, m.to_s].compact.join('.') }.sort
+  end
+end
+
+Bacon::Context.send(:include, CompletionHelper)
+
+class CompletionStub
+  def self.a_cmethod
+  end
+  
+  def an_imethod
+  end
+end
+
+class Playground
+  CompletionStub = Object.new
+  def CompletionStub.a_singleton_method; end
+  
+  def a_local_method; end
+end
+
+$a_completion_stub = CompletionStub.new
+
+describe "IRB::Completion" do
+  before do
+    @context = IRB::Context.new(Playground.new)
+  end
+  
+  it "quacks like a Proc" do
+    IRB::Completion.call('//.').should == imethods(Regexp, '//')
+  end
+  
+  describe "when doing a method call on an explicit receiver," do
+    describe "and the source ends with a period," do
+      describe "returns *all* public methods of the receiver that" do
+        it "matches as a local variable" do
+          @context.__evaluate__('foo = ::CompletionStub.new')
+          complete('foo.').should == imethods(::CompletionStub, 'foo')
+          
+          @context.__evaluate__('def foo.singleton_method; end')
+          complete('foo.').should.include('foo.singleton_method')
+        end
+        
+        it "matches as a global variable" do
+          complete('$a_completion_stub.').should == imethods(::CompletionStub, '$a_completion_stub')
+        end
+        
+        # TODO: fix
+        # it "matches as a local constant" do
+        #   complete('CompletionStub.').should == methods(Playground::CompletionStub)
+        # end
+        
+        it "matches as a top level constant" do
+          complete('::CompletionStub.').should == methods(::CompletionStub, '::CompletionStub')
+        end
+      end
+      
+      describe "returns *all* public instance methods of the class (the receiver) that" do
+        it "matches as a Regexp literal" do
+          complete('//.').should == imethods(Regexp, '//')
+          complete('/^(:[^:.]+)\.([^.]*)$/.').should == imethods(Regexp, '/^(:[^:.]+)\.([^.]*)$/')
+          complete('/^(#{oops})\.([^.]*)$/.').should == imethods(Regexp, '/^(#{oops})\.([^.]*)$/')
+          complete('%r{/foo/.*/bar}.').should == imethods(Regexp, '%r{/foo/.*/bar}')
+        end
+        
+        it "matches as an Array literal" do
+          complete('[].').should == imethods(Array, '[]')
+          complete('[:ok, {}, "foo",].').should == imethods(Array, '[:ok, {}, "foo",]')
+          complete('[*foo].').should == imethods(Array, '[*foo]')
+          complete('%w{foo}.').should == imethods(Array, '%w{foo}')
+          complete('%W{#{:foo}}.').should == imethods(Array, '%W{#{:foo}}')
+        end
+        
+        # fails on MacRuby
+        it "matches as a lambda literal" do
+          complete('->{}.').should == imethods(Proc, '->{}')
+          complete('->{x=:ok}.').should == imethods(Proc, '->{x=:ok}')
+          complete('->(x){x=:ok}.').should == imethods(Proc, '->(x){x=:ok}')
+        end
+        
+        it "matches as a Hash literal" do
+          complete('{}.').should == imethods(Hash, '{}')
+          complete('{:foo=>:bar,}.').should == imethods(Hash, '{:foo=>:bar,}')
+          complete('{foo:"bar"}.').should == imethods(Hash, '{foo:"bar"}')
+        end
+        
+        it "matches as a Symbol literal" do
+          complete(':foo.').should == imethods(Symbol, ':foo')
+          complete(':"foo.bar".').should == imethods(Symbol, ':"foo.bar"')
+          complete(':"foo.#{"bar"}".').should == imethods(Symbol, ':"foo.#{"bar"}"')
+          complete(':\'foo.#{"bar"}\'.').should == imethods(Symbol, ':\'foo.#{"bar"}\'')
+          complete('%s{foo.bar}.').should == imethods(Symbol, '%s{foo.bar}')
+        end
+        
+        it "matches as a String literal" do
+          complete("'foo\\'bar'.").should == imethods(String, "'foo\\'bar'")
+          complete('"foo\"bar".').should == imethods(String, '"foo\"bar"')
+          complete('"foo#{"bar"}".').should == imethods(String, '"foo#{"bar"}"')
+          complete('%{foobar}.').should == imethods(String, '%{foobar}')
+          complete('%q{foo#{:bar}}.').should == imethods(String, '%q{foo#{:bar}}')
+          complete('%Q{foo#{:bar}}.').should == imethods(String, '%Q{foo#{:bar}}')
+        end
+        
+        it "matches as a Range literal" do
+          complete('1..10.').should == imethods(Range, '1..10')
+          complete('1...10.').should == imethods(Range, '1...10')
+          complete('"a".."z".').should == imethods(Range, '"a".."z"')
+          complete('"a"..."z".').should == imethods(Range, '"a"..."z"')
+        end
+        
+        it "matches as a Fixnum literal" do
+          complete('42.').should == imethods(Fixnum, '42')
+          complete('+42.').should == imethods(Fixnum, '+42')
+          complete('-42.').should == imethods(Fixnum, '-42')
+          complete('42_000.').should == imethods(Fixnum, '42_000')
+        end
+        
+        it "matches as a Bignum literal as a Fixnum" do
+          complete('100_000_000_000_000_000_000.').should == imethods(Fixnum, '100_000_000_000_000_000_000')
+          complete('-100_000_000_000_000_000_000.').should == imethods(Fixnum, '-100_000_000_000_000_000_000')
+          complete('+100_000_000_000_000_000_000.').should == imethods(Fixnum, '+100_000_000_000_000_000_000')
+        end
+        
+        it "matches as a Float with exponential literal" do
+          complete('1.2e-3.').should == imethods(Float, '1.2e-3')
+          complete('+1.2e-3.').should == imethods(Float, '+1.2e-3')
+          complete('-1.2e-3.').should == imethods(Float, '-1.2e-3')
+        end
+        
+        it "matches as a hex literal as a Fixnum" do
+          complete('0xffff.').should == imethods(Fixnum, '0xffff')
+          complete('+0xffff.').should == imethods(Fixnum, '+0xffff')
+          complete('-0xffff.').should == imethods(Fixnum, '-0xffff')
+        end
+        
+        it "matches as a binary literal as a Fixnum" do
+          complete('0b01011.').should == imethods(Fixnum, '0b01011')
+          complete('-0b01011.').should == imethods(Fixnum, '-0b01011')
+          complete('+0b01011.').should == imethods(Fixnum, '+0b01011')
+        end
+        
+        it "matches as an octal literal as a Fixnum" do
+          complete('0377.').should == imethods(Fixnum, '0377')
+          complete('-0377.').should == imethods(Fixnum, '-0377')
+          complete('+0377.').should == imethods(Fixnum, '+0377')
+        end
+        
+        it "matches as a Float literal" do
+          complete('42.0.').should == imethods(Float, '42.0')
+          complete('-42.0.').should == imethods(Float, '-42.0')
+          complete('+42.0.').should == imethods(Float, '+42.0')
+          complete('42_000.0.').should == imethods(Float, '42_000.0')
+        end
+        
+        it "matches as a Bignum float literal as a Float" do
+          complete('100_000_000_000_000_000_000.0.').should == imethods(Float, '100_000_000_000_000_000_000.0')
+          complete('+100_000_000_000_000_000_000.0.').should == imethods(Float, '+100_000_000_000_000_000_000.0')
+          complete('-100_000_000_000_000_000_000.0.').should == imethods(Float, '-100_000_000_000_000_000_000.0')
+        end
+      end
+    end
+    
+    describe "and the source does *not* end with a period," do
+      it "filters the methods, of the literal receiver, by the given method name" do
+        complete('//.nam').should == %w{ //.named_captures //.names }
+        complete('//.named').should == %w{ //.named_captures }
+      end
+      
+      it "filters the methods, of the variable receiver, by the given method name" do
+        @context.__evaluate__('foo = ::CompletionStub.new')
+        complete('foo.an_im').should == %w{ foo.an_imethod }
+        complete('$a_completion_stub.an_im').should == %w{ $a_completion_stub.an_imethod }
+        # TODO: fix
+        # complete('CompletionStub.a_sing').should == %w{ CompletionStub.a_singleton_method }
+      end
+    end
+  end
+  
+  describe "when *not* doing a method call on an explicit receiver" do
+    before do
+      @context.__evaluate__("a_local_variable = :ok")
+    end
+    
+    it "matches local variables" do
+      complete("a_local_v").should == %w{ a_local_variable }
+    end
+    
+    it "matches instance methods of the context object" do
+      complete("a_local_m").should == %w{ a_local_method }
+    end
+    
+    it "matches local variables and instance method of the context object" do
+      complete("a_loc").should == %w{ a_local_method a_local_variable }
+    end
+    
+    it "matches global variables" do
+      complete("$a_completion_s").should == %w{ $a_completion_stub }
+    end
+    
+    it "matches constants" do
+      complete("Playgr").should == %w{ Playground }
+    end
+    
+    it "matches top level constants" do
+      complete("::CompletionSt").should == %w{ ::CompletionStub }
+    end
+  end
+end

data/spec/context_spec.rb

@@ -1,6 +1,19 @@
 require File.expand_path('../spec_helper', __FILE__)
 require 'tempfile'
 
+class << Readline
+  attr_reader :received
+  
+  def stub_input(*input)
+    @input = input
+  end
+  
+  def readline(prompt, history)
+    @received = [prompt, history]
+    @input.shift
+  end
+end
+
 main = self
 
 describe "IRB::Context" do
@@ -45,6 +58,16 @@ describe "IRB::Context" do
     @context.format_exception(exception).should ==
       "NameError: uninitialized constant Bacon::Context::DoesNotExist\n\t#{exception.backtrace.join("\n\t")}"
   end
+  
+  it "makes itself the current running context during the runloop and resigns once it's done" do
+    IRB::Context.current.should == nil
+    
+    Readline.stub_input("current_during_run = IRB::Context.current")
+    @context.run
+    eval('current_during_run', @context.binding).should == @context
+    
+    IRB::Context.current.should == nil
+  end
 end
 
 describe "IRB::Context, when evaluating source" do
@@ -54,7 +77,7 @@ describe "IRB::Context, when evaluating source" do
   end
   
   it "evaluates code with the object's binding" do
-    @context.evaluate("self").should == main
+    @context.__evaluate__("self").should == main
   end
   
   it "prints the result" do
@@ -89,19 +112,6 @@ describe "IRB::Context, when evaluating source" do
   end
 end
 
-class << Readline
-  attr_reader :received
-  
-  def stub_input(*input)
-    @input = input
-  end
-  
-  def readline(prompt, history)
-    @received = [prompt, history]
-    @input.shift
-  end
-end
-
 describe "IRB::Context, when receiving input" do
   before do
     @context = IRB::Context.new(main)
@@ -145,6 +155,17 @@ describe "IRB::Context, when receiving input" do
     source.to_s.should == "def foo\n:ok\nend; p foo"
   end
   
+  it "prints that a syntax error occurred on the last line and reset the buffer to the previous line" do
+    def @context.puts(str); @printed = str; end
+    
+    @context.process_line("def foo")
+    @context.process_line("  };")
+    
+    @context.source.to_s.should == "def foo"
+    printed = @context.instance_variable_get(:@printed)
+    printed.should == "SyntaxError: compile error\n(irb):2: syntax error, unexpected '}'"
+  end
+  
   it "returns whether or not the runloop should continue, but only if the level is 0" do
     @context.process_line("def foo").should == true
     @context.process_line("quit").should == true

data/spec/irb_spec.rb

@@ -1,10 +1,10 @@
 require File.expand_path('../spec_helper', __FILE__)
 
-describe "Kernel::IRB()" do
+describe "Kernel::irb" do
   it "creates a new context for the given object and runs it" do
     Readline.stub_input("::IRBRan = self")
     o = Object.new
-    IRB(o)
+    irb(o)
     IRBRan.should == o
   end
 end

data/spec/source_spec.rb

@@ -1,5 +1,9 @@
 require File.expand_path('../spec_helper', __FILE__)
 
+class Should
+  alias have be
+end
+
 describe "IRB::Source" do
   before do
     @source = IRB::Source.new
@@ -15,6 +19,13 @@ describe "IRB::Source" do
     @source.buffer.should == %w{ foo bar }
   end
   
+  it "removes the last line from the buffer" do
+    @source << "foo\n"
+    @source << "bar\r\n"
+    @source.pop.should == "bar"
+    @source.buffer.should == %w{ foo }
+  end
+  
   it "returns the full buffered source, joined by newlines" do
     @source.source.should == ""
     @source << "foo\n"
@@ -34,7 +45,7 @@ describe "IRB::Source" do
       ["def foo", "p :ok", "end"],
       ["class A; def", "foo(x); p x", "end; end"]
     ].each do |buffer|
-      IRB::Source.new(buffer).should.be.valid
+      IRB::Source.new(buffer).should.be.code_block
     end
   end
   
@@ -43,10 +54,18 @@ describe "IRB::Source" do
       ["def foo", "p :ok"],
       ["class A; def", "foo(x); p x", "end"]
     ].each do |buffer|
-      IRB::Source.new(buffer).should.not.be.valid
+      IRB::Source.new(buffer).should.not.be.code_block
     end
   end
   
+  it "returns whether or not the accumulated source contains a syntax error" do
+    @source.should.not.have.syntax_error
+    @source << "def foo"
+    @source.should.not.have.syntax_error
+    @source << "  def;"
+    @source.should.have.syntax_error
+  end
+  
   it "returns the current code block indentation level" do
     @source.level.should == 0
     @source << "class A"
@@ -71,14 +90,23 @@ describe "IRB::Source" do
     @source << "def foo"
     reflection = @source.reflect
     @source.level
-    @source.valid?
+    @source.code_block?
     @source.reflect.should == reflection
     
     @source << "end"
     @source.level
     new_reflection = @source.reflect
     new_reflection.should.not == reflection
-    @source.valid?
+    @source.code_block?
+    @source.reflect.should == new_reflection
+    
+    reflection = new_reflection
+    
+    @source.pop
+    @source.level
+    new_reflection = @source.reflect
+    new_reflection.should.not == reflection
+    @source.syntax_error?
     @source.reflect.should == new_reflection
   end
 end
@@ -89,9 +117,24 @@ describe "IRB::Source::Reflector" do
   end
   
   it "returns whether or not the source is a valid code block" do
-    reflect("def foo").should.not.be.valid
-    reflect("def foo; p :ok").should.not.be.valid
-    reflect("def foo; p :ok; end").should.be.valid
+    reflect("def foo").should.not.be.code_block
+    reflect("def foo; p :ok").should.not.be.code_block
+    reflect("def foo; p :ok; end").should.be.code_block
+  end
+  
+  it "returns whether or not the source contains a syntax error, except a code block not ending" do
+    reflect("def;").should.have.syntax_error
+    reflect("def;").should.have.syntax_error
+    reflect("def foo").should.not.have.syntax_error
+    reflect("class A; }").should.have.syntax_error
+    reflect("class A; {" ).should.not.have.syntax_error
+    reflect("class A def foo").should.have.syntax_error
+    reflect("class A; def foo" ).should.not.have.syntax_error
+  end
+  
+  it "returns the actual syntax error message if one occurs" do
+    reflect("def foo").syntax_error.should == nil
+    reflect("}").syntax_error.should == "syntax error, unexpected '}'"
   end
   
   it "returns the code block indentation level" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dietrb
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Eloy Duran
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-07 00:00:00 +01:00
+date: 2010-02-18 00:00:00 +01:00
 default_executable: dietrb
 dependencies: []
 
@@ -20,18 +20,22 @@ executables:
 extensions: []
 
 extra_rdoc_files: 
-- README
+- LICENSE
+- README.rdoc
 files: 
 - .gitignore
-- README
+- LICENSE
+- README.rdoc
 - Rakefile
 - VERSION
 - bin/dietrb
 - dietrb.gemspec
 - lib/irb.rb
 - lib/irb/context.rb
+- lib/irb/ext/completion.rb
 - lib/irb/ext/macruby.rb
 - lib/irb/source.rb
+- spec/completion_spec.rb
 - spec/context_spec.rb
 - spec/irb_spec.rb
 - spec/source_spec.rb
@@ -65,6 +69,7 @@ signing_key:
 specification_version: 3
 summary: IRB on a diet, for MacRuby / Ruby 1.9
 test_files: 
+- spec/completion_spec.rb
 - spec/context_spec.rb
 - spec/irb_spec.rb
 - spec/source_spec.rb

data/README

@@ -1 +0,0 @@
-IRB on a diet, for MacRuby / Ruby 1.9