dietrb 0.4.7 → 0.5.0

data/lib/irb/driver/readline.rb

@@ -0,0 +1,26 @@
+require 'readline'
+require 'irb/driver/tty'
+require 'irb/ext/history'
+require 'irb/ext/completion'
+
+module IRB
+  module Driver
+    class Readline < TTY
+      
+      def initialize(input = $stdin, output = $stdout)
+        super
+        ::Readline.input  = @input
+        ::Readline.output = @output
+        ::Readline.completion_proc = IRB::Completion.new
+      end
+      
+      def readline
+        source = ::Readline.readline(context.prompt, true)
+        IRB::History.input(source)
+        source
+      end
+    end
+  end
+end
+
+IRB::Driver.current = IRB::Driver::Readline.new

data/lib/irb/driver/socket.rb

@@ -0,0 +1,44 @@
+require 'irb/driver/tty'
+require 'socket'
+
+module IRB
+  module Driver
+    class Socket
+      # Initializes with the object and binding that each new connection will
+      # get as Context. The binding is shared, so local variables will stay
+      # around. The benefit of this is that a socket based irb session is most
+      # probably used to debug a running application in development. In this
+      # scenario it could be beneficial to keep local vars in between sessions.
+      #
+      # TODO see if that actually works out ok.
+      def initialize(object, binding, host = '127.0.0.1', port = 7829)
+        @object, @binding = object, binding
+        @host, @port = host, port
+        @server = TCPServer.new(host, port)
+      end
+      
+      # TODO libedit doesn't use the right input and output, so we can't use Readline for now!!
+      def run
+        $stderr.puts "[!] Running IRB server on #{@host}:#{@port}"
+        loop do
+          connection = @server.accept
+          Thread.new do
+            # assign driver with connection to current thread and start runloop
+            IRB::Driver.current = TTY.new(connection, connection)
+            irb(@object, @binding)
+            connection.close
+          end
+        end
+      end
+    end
+  end
+end
+
+def self.irb(object, binding = nil)
+  unless @server
+    @server = IRB::Driver::Socket.new(object, binding)
+    @server.run
+  else
+    super
+  end
+end

data/lib/irb/driver/tty.rb

@@ -0,0 +1,58 @@
+require 'irb/driver'
+
+module IRB
+  module Driver
+    class TTY
+      attr_reader :input, :output, :context_stack
+      
+      def initialize(input = $stdin, output = $stdout)
+        @input  = input
+        @output = output
+        @context_stack = []
+      end
+      
+      def context
+        @context_stack.last
+      end
+      
+      def readline
+        @output.print(context.prompt)
+        @input.gets
+      end
+      
+      # TODO make it take the current context instead of storing it
+      def consume
+        readline
+      rescue Interrupt
+        context.clear_buffer
+        ""
+      end
+      
+      # Feeds input into a given context.
+      #
+      # Ensures that the standard output object is a OutputRedirector, or a
+      # subclass thereof.
+      def run(context)
+        @context_stack << context
+        before, $stdout = $stdout, OutputRedirector.new unless $stdout.is_a?(OutputRedirector)
+        while line = consume
+          break unless context.process_line(line)
+        end
+      ensure
+        @context_stack.pop
+        $stdout = before if before
+      end
+    end
+  end
+end
+
+IRB::Driver.current = IRB::Driver::TTY.new
+
+module Kernel
+  # Creates a new IRB::Context with the given +object+ and runs it.
+  def irb(object, binding = nil)
+    IRB::Driver.current.run(IRB::Context.new(object, binding))
+  end
+  
+  private :irb
+end

data/lib/irb/ext/completion.rb

@@ -36,22 +36,23 @@ module IRB
       yield
     }
     
+    attr_reader :source
+    
+    def context
+      IRB::Driver.current.context
+    end
+    
     # 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
+    def call(source)
+      @source = source
+      results
     end
     
     def evaluate(s)
-      @context.__evaluate__(s)
+      context.__evaluate__(s)
     end
     
     def local_variables
@@ -59,7 +60,7 @@ module IRB
     end
     
     def instance_methods
-      @context.object.methods.map(&:to_s)
+      context.object.methods.map(&:to_s)
     end
     
     def instance_methods_of(klass)
@@ -190,5 +191,5 @@ if defined?(Readline)
     # * Hash: = and >
     Readline.basic_word_break_characters= " \t\n`<;|&("
   end
-  Readline.completion_proc = IRB::Completion
-end
+  # Readline.completion_proc = IRB::Completion
+end

data/lib/irb/ext/history.rb

@@ -7,67 +7,62 @@
 # Portions Copyright (C) 2006-2010 Ben Bleything <ben@bleything.net> (Kernel#history & Kernel#history!)
 
 module IRB
-  class History
+  module History
     class << self
       attr_accessor :file, :max_entries_in_overview
       
-      def current
-        IRB::Context.current.processors.find do |processor|
-          processor.is_a?(IRB::History)
-        end
+      def setup
+        to_a.each do |source|
+          Readline::HISTORY.push(source)
+        end if Readline::HISTORY.to_a.empty?
       end
-    end
-    
-    def initialize(context)
-      @context = context
       
-      to_a.each do |source|
-        Readline::HISTORY.push(source)
-      end if Readline::HISTORY.to_a.empty?
-    end
-    
-    def input(source)
-      File.open(self.class.file, "a") { |f| f.puts(source) }
-      source
-    end
-    
-    def to_a
-      file = self.class.file
-      File.exist?(file) ? File.read(file).split("\n") : []
-    end
-    
-    def clear!
-      File.open(self.class.file, "w") { |f| f << "" }
-      Readline::HISTORY.clear
-    end
-    
-    def history(number_of_entries = max_entries_in_overview)
-      history_size = Readline::HISTORY.size
-      start_index = 0
+      def context
+        IRB::Driver.current.context
+      end
       
-      # always remove one extra, because that's the `history' command itself
-      if history_size <= number_of_entries
-        end_index = history_size - 2
-      else
-        end_index = history_size - 2
-        start_index = history_size - number_of_entries - 1
+      def input(source)
+        File.open(file, "a") { |f| f.puts(source) }
+        source
       end
       
-      start_index.upto(end_index) do |i|
-        puts "#{i}: #{Readline::HISTORY[i]}"
+      def to_a
+        File.exist?(file) ? File.read(file).split("\n") : []
+      end
+      
+      def clear!
+        File.open(file, "w") { |f| f << "" }
+        Readline::HISTORY.clear
+      end
+      
+      def history(number_of_entries = max_entries_in_overview)
+        history_size = Readline::HISTORY.size
+        start_index = 0
+        
+        # always remove one extra, because that's the `history' command itself
+        if history_size <= number_of_entries
+          end_index = history_size - 2
+        else
+          end_index = history_size - 2
+          start_index = history_size - number_of_entries - 1
+        end
+        
+        start_index.upto(end_index) do |i|
+          puts "#{i}: #{Readline::HISTORY[i]}"
+        end
       end
-    end
-    
-    def history!(entry_or_range)
-      # we don't want to execute history! again
-      @context.clear_buffer
       
-      if entry_or_range.is_a?(Range)
-        entry_or_range.to_a.each do |i|
-          @context.input_line(Readline::HISTORY[i])
+      def history!(entry_or_range)
+        # we don't want to execute history! again
+        context.clear_buffer
+        
+        if entry_or_range.is_a?(Range)
+          entry_or_range.to_a.each do |i|
+            context.input_line(Readline::HISTORY[i])
+          end
+        else
+          context.input_line(Readline::HISTORY[entry_or_range])
         end
-      else
-        @context.input_line(Readline::HISTORY[entry_or_range])
       end
     end
   end
@@ -75,23 +70,23 @@ end
 
 module Kernel
   def history(number_of_entries = IRB::History.max_entries_in_overview)
-    IRB::History.current.history(number_of_entries)
-    nil
+    IRB::History.history(number_of_entries)
+    IRB::Context::IGNORE_RESULT
   end
   alias_method :h, :history
   
   def history!(entry_or_range)
-    IRB::History.current.history!(entry_or_range)
-    nil
+    IRB::History.history!(entry_or_range)
+    IRB::Context::IGNORE_RESULT
   end
   alias_method :h!, :history!
   
   def clear_history!
-    IRB::History.current.clear!
-    nil
+    IRB::History.clear!
+    true
   end
 end
 
-IRB::Context.processors << IRB::History
 IRB::History.file = File.expand_path("~/.irb_history")
-IRB::History.max_entries_in_overview = 50
+IRB::History.max_entries_in_overview = 50
+IRB::History.setup

data/lib/irb/formatter.rb

@@ -38,7 +38,9 @@ module IRB
     
     def inspect_object(object)
       if @inspect
-        object.respond_to?(:pretty_inspect) ? object.pretty_inspect : object.inspect
+        result = object.respond_to?(:pretty_inspect) ? object.pretty_inspect : object.inspect
+        result.strip!
+        result
       else
         address = object.__id__ * 2
         address += 0x100000000 if address < 0

data/lib/irb/version.rb

@@ -8,8 +8,8 @@ module IRB
   module VERSION #:nodoc:
     NAME  = 'DietRB'
     MAJOR = 0
-    MINOR = 4
-    TINY  = 7
+    MINOR = 5
+    TINY  = 0
     
     STRING = [MAJOR, MINOR, TINY].join('.')
     DESCRIPTION = "#{NAME} (#{STRING})"

data/spec/context_spec.rb

@@ -1,22 +1,6 @@
 require File.expand_path('../spec_helper', __FILE__)
 require 'tempfile'
 
-def stub_Readline
-  class << Readline
-    attr_reader :received
-    
-    def stub_input(*input)
-      @input = input
-    end
-    
-    def readline(prompt, history)
-      @received = [prompt, history]
-      @input.shift
-    end
-  end
-end
-stub_Readline
-
 class TestProcessor
   def input(s)
     s * 2
@@ -28,6 +12,7 @@ main = self
 describe "IRB::Context" do
   before do
     @context = IRB::Context.new(main)
+    @context.extend(OutputStubMixin)
   end
   
   it "initializes with an object and stores a copy of its binding" do
@@ -41,46 +26,24 @@ describe "IRB::Context" do
   it "initializes with an object and an explicit binding" do
     context = IRB::Context.new(Object.new, TOPLEVEL_BINDING)
     eval("class InTopLevel; end", context.binding)
-    lambda { ::InTopLevel }.should.not.raise NameError
+    lambda { ::InTopLevel }.should_not raise_error(NameError)
   end
   
   it "initializes with an 'empty' state" do
     @context.line.should == 1
-    @context.source.should.be.instance_of IRB::Source
+    @context.source.class.should == IRB::Source
     @context.source.to_s.should == ""
   end
   
-  it "initializes with an instance of each processor" do
-    before = IRB::Context.processors.dup
-    begin
-      IRB::Context.processors << TestProcessor
-      @context = IRB::Context.new(main)
-      @context.processors.last.should.be.instance_of TestProcessor
-    ensure
-      IRB::Context.processors.replace(before)
-    end
-  end
-  
   it "does not use the same binding copy of the top level object" do
-    lambda { eval("x", @context.binding) }.should.raise NameError
-  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
+    lambda { eval("x", @context.binding) }.should raise_error(NameError)
   end
 end
 
 describe "IRB::Context, when evaluating source" do
   before do
     @context = IRB::Context.new(main)
-    def @context.printed;      @printed ||= ''          end
-    def @context.puts(string); printed << "#{string}\n" end
+    @context.extend(OutputStubMixin)
     IRB.formatter = IRB::Formatter.new
   end
   
@@ -109,59 +72,43 @@ describe "IRB::Context, when evaluating source" do
     lambda {
       @context.evaluate("DoesNotExist")
       @context.evaluate("raise Exception")
-    }.should.not.raise
+    }.should_not.raise_error
   end
   
-  it "assigns the last raised exception to the global variable `$EXCEPTION' / `$e'" do
+  it "assigns the last raised exception to the variables `exception' / `e'" do
     @context.evaluate("DoesNotExist")
-    $EXCEPTION.should.be.instance_of NameError
-    $EXCEPTION.message.should.include 'DoesNotExist'
-    $e.should == $EXCEPTION
+    @context.__evaluate__("exception").class.should == NameError
+    @context.__evaluate__("exception").message.should include('DoesNotExist')
+    @context.__evaluate__("e").should == @context.__evaluate__("exception")
   end
   
   it "prints the exception that occurs" do
     @context.evaluate("DoesNotExist")
-    @context.printed.should.match /^NameError:.+DoesNotExist/
+    @context.printed.should =~ /^NameError:.+DoesNotExist/
   end
   
   it "uses the line number of the *first* line in the buffer, for the line parameter of eval" do
     @context.process_line("DoesNotExist")
-    @context.printed.should.match /\(irb\):1:in/
+    @context.printed.should =~ /\(irb\):1:in/
     @context.process_line("class A")
     @context.process_line("DoesNotExist")
     @context.process_line("end")
-    @context.printed.should.match /\(irb\):3:in.+\(irb\):2:in/m
+    @context.printed.should =~ /\(irb\):3:in.+\(irb\):2:in/m
   end
   
-  it "inputs a line to be processed, skipping readline" do
-    expected = "#{@context.formatter.prompt(@context)}2 * 21\n=> 42\n"
-    @context.input_line("2 * 21")
-    @context.printed.should == expected
+  it "ignores the result if it's IRB::Context::IGNORE_RESULT" do
+    @context.evaluate(":bananas")
+    @context.evaluate("IRB::Context::IGNORE_RESULT").should == nil
+    @context.printed.should == "=> :bananas\n"
+    @context.evaluate("_").should == :bananas
   end
 end
 
 describe "IRB::Context, when receiving input" do
   before do
     @context = IRB::Context.new(main)
-  end
-  
-  it "prints the prompt, reads a line, saves it to the history and returns it" do
-    Readline.stub_input("def foo")
-    @context.readline.should == "def foo"
-    Readline.received.should == ["irb(main):001:0> ", true]
-  end
-  
-  it "passes the input to all processors, which may return a new value" do
-    @context.processors << TestProcessor.new
-    Readline.stub_input("foo")
-    @context.readline.should == "foofoo"
-  end
-  
-  it "processes the output" do
-    Readline.stub_input("def foo")
-    def @context.process_line(line); @received = line; false; end
-    @context.run
-    @context.instance_variable_get(:@received).should == "def foo"
+    @context.extend(InputStubMixin)
+    @context.extend(OutputStubMixin)
   end
   
   it "adds the received code to the source buffer" do
@@ -170,22 +117,10 @@ describe "IRB::Context, when receiving input" do
     @context.source.to_s.should == "def foo\np :ok"
   end
   
-  it "clears the source buffer when an Interrupt signal is received" do
-    begin
-      @context.process_line("def foo")
-      
-      def Readline.readline(*args)
-        unless @raised
-          @raised = true
-          raise Interrupt
-        end
-      end
-      
-      lambda { @context.run }.should.not.raise Interrupt
-      @context.source.to_s.should == ""
-    ensure
-      stub_Readline
-    end
+  it "clears the source buffer" do
+    @context.process_line("def foo")
+    @context.clear_buffer
+    @context.source.to_s.should == ""
   end
   
   it "increases the current line number" do
@@ -208,14 +143,11 @@ describe "IRB::Context, when receiving input" do
   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 '}'"
+    @context.printed.should == "SyntaxError: compile error\n(irb):2: syntax error, unexpected '}'\n"
   end
   
   it "returns whether or not the runloop should continue, but only if the level is 0" do
@@ -226,19 +158,9 @@ describe "IRB::Context, when receiving input" do
     @context.process_line("quit").should == false
   end
   
-  it "exits the runloop if the user wishes so" do
-    Readline.stub_input("quit", "def foo")
-    def @context.process_line(line); @received = line; super; end
-    @context.run
-    @context.instance_variable_get(:@received).should.not == "def foo"
-  end
-end
-
-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)
-    IRBRan.should == o
+  it "inputs a line to be processed" do
+    expected = "#{@context.formatter.prompt(@context)}2 * 21\n=> 42\n"
+    @context.input_line("2 * 21")
+    @context.printed.should == expected
   end
 end