dietrb 0.3.0 → 0.4.0

data/LICENSE

@@ -1,3 +1,8 @@
 Copyright (c) <2010> Eloy Duran, <eloy.de.enige@gmail.com>
 
+Portions Copyright (c) 2006-2010 Ben Bleything (history utils)
+Portions Copyright (c) 2006-2010 Paul Duncan <pabs@pablotron.org> (Wirble)
+Portions Copyright (c) 2009-2010 Jens Wille <jens.wille@gmail.com> (Wirble)
+Portions Copyright (c) 2006-2010 Giles Bowkett (light background color scheme)
+
 This software is available under the Ruby license.

data/README.rdoc

@@ -11,6 +11,39 @@ 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.
 
+== Extensions
+
+* irb/ext/colorize.rb, adds support for colorizing the prompt and result. The
+  code was based upon Wirble's implementation, so your custom Wirble themes
+  should still work.
+  
+  Configure it with:
+  
+  * IRB.formatter.color_scheme = scheme, where scheme can be: :dark_background,
+    :light_background, or :fresh. Defaults to :dark_background.
+  
+  * IRB.formatter.colors returns the hash of current token-type to color
+    mappings.
+
+* irb/ext/completion.rb, adds, as the name implies, autocompletion for
+  constants, variables, methods, etc.
+
+* irb/ext/history.rb, stores/loads the history in and from the history file,
+  which is located at ~/.irb_history.
+  
+  It provides the following API:
+  
+  * Kernel#history(N), or Kernel#h, will show N number of the most recent history
+    entries. Defaults to 50.
+  
+  * Kernel#history!(entry_or_range), or Kernel#h!, will execute the specified
+    history entry, or entries if a range is given.
+  
+  * Kernel#clear_history! will clear the history and the history file.
+
+* irb/ext/macruby.rb, adds support for Cocoa development by starting an
+  NSRunloop. Loaded by default on MacRuby.
+
 == Differences
 
 * This IRB version specifically targets MacRuby, for now, and allows Cocoa

data/Rakefile

@@ -2,7 +2,8 @@ task :default => :run
 
 desc "Run the specs"
 task :spec do
-  sh "macbacon #{FileList['spec/**/*_spec.rb'].join(' ')}"
+  # sh "macbacon #{FileList['spec/**/*_spec.rb'].join(' ')}"
+  sh "bacon19 #{FileList['spec/**/*_spec.rb'].join(' ')}"
 end
 
 desc "Run specs with Kicker"
@@ -12,7 +13,7 @@ end
 
 desc "Run dietrb with ruby19"
 task :run do
-  sh "ruby19 -Ilib ./bin/dietrb -r irb/ext/completion"
+  sh "ruby19 -Ilib ./bin/dietrb -r irb/ext/completion -r irb/ext/colorize -r pp"
 end
 
 begin
@@ -25,6 +26,7 @@ begin
     gemspec.authors = ["Eloy Duran"]
     
     gemspec.required_ruby_version = ::Gem::Requirement.new("~> 1.9")
+    gemspec.files.reject! { |file| file =~ /^extensions/ }
   end
 rescue LoadError
 end

data/TODO

@@ -0,0 +1,7 @@
+* Add history manager support
+* Add colored output, possibly based on the Wirble code
+* Make sure the following formatters work: hirb, awesome_print, and looksee
+* Make sure the majority of the utils in utility_belt work
+* Possibly add copy-paste support as an ext
+* Make sure ported/used code is attributed and contact authors about Ruby license
+* Decide whether or not we need more control for colorizing which could be done with Ripper::SexpBuilder

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/bin/dietrb

@@ -20,6 +20,9 @@ unless ARGV.empty?
   end.parse!(ARGV)
 end
 
+irbrc = File.expand_path("~/.irbrc")
+load(irbrc) if File.exist?(irbrc)
+
 IRB.formatter.filter_from_backtrace << /^#{__FILE__}/
 
 if ARGV.empty?
@@ -28,9 +31,6 @@ else
   path = ARGV.shift
   context = IRB::Context.new(self, TOPLEVEL_BINDING.dup)
   File.open(path, 'r') do |file|
-    file.each_line do |line|
-      puts IRB.formatter.prompt(context) + line
-      context.process_line(line)
-    end
+    file.each_line { |line| context.input_line(line) }
   end
 end

data/dietrb.gemspec

@@ -5,37 +5,42 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dietrb}
-  s.version = "0.3.0"
+  s.version = "0.4.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-24}
+  s.date = %q{2010-04-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 = [
     "LICENSE",
-     "README.rdoc"
+     "README.rdoc",
+     "TODO"
   ]
   s.files = [
     ".gitignore",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
+     "TODO",
      "VERSION",
      "bin/dietrb",
      "dietrb.gemspec",
      "lib/irb.rb",
      "lib/irb/context.rb",
+     "lib/irb/ext/colorize.rb",
      "lib/irb/ext/completion.rb",
+     "lib/irb/ext/history.rb",
      "lib/irb/ext/macruby.rb",
      "lib/irb/formatter.rb",
      "lib/irb/source.rb",
+     "spec/colorize_spec.rb",
      "spec/completion_spec.rb",
      "spec/context_spec.rb",
      "spec/formatter_spec.rb",
-     "spec/irb_spec.rb",
+     "spec/history_spec.rb",
      "spec/source_spec.rb",
      "spec/spec_helper.rb"
   ]
@@ -46,10 +51,11 @@ 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/completion_spec.rb",
+    "spec/colorize_spec.rb",
+     "spec/completion_spec.rb",
      "spec/context_spec.rb",
      "spec/formatter_spec.rb",
-     "spec/irb_spec.rb",
+     "spec/history_spec.rb",
      "spec/source_spec.rb",
      "spec/spec_helper.rb"
   ]

data/lib/irb/context.rb

@@ -7,20 +7,28 @@ module IRB
       attr_accessor :current
       
       def make_current(context)
+        # Messing with a current context is gonna bite me in the ass when we
+        # get to multi-threading, but we'll it when we get there.
         before, @current = @current, context
         yield
       ensure
         @current = before
       end
+      
+      def processors
+        @processors ||= []
+      end
     end
     
-    attr_reader :object, :binding, :line, :source
+    attr_reader :object, :binding, :line, :source, :processors
     
     def initialize(object, explicit_binding = nil)
       @object  = object
       @binding = explicit_binding || object.instance_eval { binding }
       @line    = 1
       clear_buffer
+      
+      @processors = self.class.processors.map { |processor| processor.new(self) }
     end
     
     def __evaluate__(source, file = __FILE__, line = __LINE__)
@@ -35,8 +43,11 @@ module IRB
       puts formatter.exception(e)
     end
     
+    # Reads input and passes it to all processors.
     def readline
-      Readline.readline(formatter.prompt(self), true)
+      input = Readline.readline(formatter.prompt(self), true)
+      @processors.each { |processor| input = processor.input(input) }
+      input
     rescue Interrupt
       clear_buffer
       ""
@@ -79,7 +90,10 @@ module IRB
       true
     end
     
-    private
+    def input_line(line)
+      puts formatter.prompt(self) + line
+      process_line(line)
+    end
     
     def formatter
       IRB.formatter
@@ -89,4 +103,13 @@ module IRB
       @source = Source.new
     end
   end
+end
+
+module Kernel
+  # Creates a new IRB::Context with the given +object+ and runs it.
+  def irb(object, binding = nil)
+    IRB::Context.new(object, binding).run
+  end
+  
+  private :irb
 end

data/lib/irb/ext/colorize.rb

@@ -0,0 +1,177 @@
+module IRB
+  # This code is based upon Wirble (http://pablotron.org/software/wirble/) by
+  # Paul Duncan and Jens Wille.
+  class ColoredFormatter < Formatter
+    TYPE_ALIASES = {
+      :on_comma           => :comma,
+      :refers             => :operator, # Wirble compat
+      :on_op              => :operator,
+      
+      :on_lbrace          => :open_hash,
+      :on_rbrace          => :close_hash,
+      :on_lbracket        => :open_array,
+      :on_rbracket        => :close_array,
+      
+      :on_ident           => :symbol,
+      :on_symbeg          => :symbol_prefix,
+      
+      :on_tstring_beg     => :open_string,
+      :on_tstring_content => :string,
+      :on_tstring_end     => :close_string,
+      
+      :on_int             => :number,
+      :on_kw              => :keyword,
+      :on_const           => :constant,
+      :class              => :constant # Wirble compat
+    }
+    
+    # # object colors
+    # :open_object        => :dark_gray,
+    # :object_class       => :purple,
+    # :object_addr_prefix => :blue,
+    # :object_line_prefix => :blue,
+    # :close_object       => :dark_gray,
+    
+    COLOR_SCHEMES = {
+      :dark_background => {
+        # :prompt             => :green,
+        # :result_prefix      => :light_purple,
+        
+        :comma              => :blue,
+        :operator           => :blue,
+        
+        :open_hash          => :green,
+        :close_hash         => :green,
+        :open_array         => :green,
+        :close_array        => :green,
+        
+        :symbol_prefix      => :yellow, # hmm ident...
+        :symbol             => :yellow,
+        
+        :open_string        => :red,
+        :string             => :cyan,
+        :close_string       => :red,
+        
+        :number             => :cyan,
+        :keyword            => :yellow,
+        :constant           => :light_green
+      },
+      :light_background => {
+        :comma              => :purple,
+        :operator           => :blue,
+        
+        :open_hash          => :red,
+        :close_hash         => :red,
+        :open_array         => :red,
+        :close_array        => :red,
+        
+        :symbol_prefix      => :black,
+        :symbol             => :light_gray,
+        
+        :open_string        => :blue,
+        :string             => :dark_gray,
+        :close_string       => :blue,
+        
+        :number             => :black,
+        :keyword            => :brown,
+        :constant           => :red
+      },
+      :fresh => {
+        :prompt             => :green,
+        :result_prefix      => :light_purple,
+        
+        :comma              => :red,
+        :operator           => :red,
+        
+        :open_hash          => :blue,
+        :close_hash         => :blue,
+        :open_array         => :green,
+        :close_array        => :green,
+        
+        :symbol_prefix      => :yellow,
+        :symbol             => :yellow,
+        
+        :number             => :cyan,
+        :string             => :cyan,
+        :keyword            => :white
+      }
+    }
+    
+    #
+    # Terminal escape codes for colors.
+    #
+    module Color
+      COLORS = {
+        :nothing      => '0;0',
+        :black        => '0;30',
+        :red          => '0;31',
+        :green        => '0;32',
+        :brown        => '0;33',
+        :blue         => '0;34',
+        :cyan         => '0;36',
+        :purple       => '0;35',
+        :light_gray   => '0;37',
+        :dark_gray    => '1;30',
+        :light_red    => '1;31',
+        :light_green  => '1;32',
+        :yellow       => '1;33',
+        :light_blue   => '1;34',
+        :light_cyan   => '1;36',
+        :light_purple => '1;35',
+        :white        => '1;37',
+      }
+      
+      #
+      # Return the escape code for a given color.
+      #
+      def self.escape(name)
+        COLORS.key?(name) && "\e[#{COLORS[name]}m"
+      end
+      
+      CLEAR = escape(:nothing)
+    end
+    
+    attr_reader :colors, :color_scheme
+    
+    def initialize
+      super
+      self.color_scheme = :dark_background
+    end
+    
+    def color_scheme=(scheme)
+      @colors = COLOR_SCHEMES[scheme].dup
+      @color_scheme = scheme
+    end
+    
+    def color(type)
+      type = TYPE_ALIASES[type] if TYPE_ALIASES.has_key?(type)
+      @colors[type]
+    end
+    
+    def colorize_token(type, token)
+      if color = color(type)
+        "#{Color.escape(color)}#{token}#{Color::CLEAR}"
+      else
+        token
+      end
+    end
+    
+    def colorize(str)
+      Ripper.lex(str).map { |_, type, token| colorize_token(type, token) }.join
+    end
+    
+    def prompt(context)
+      colorize_token(:prompt, super)
+    end
+    
+    def result_prefix
+      colorize_token(:result_prefix, Formatter::RESULT_PREFIX)
+    end
+    
+    def result(object)
+      "#{result_prefix} #{colorize(inspect_object(object))}"
+    end
+  end
+end
+
+IRB.formatter = IRB::ColoredFormatter.new

data/lib/irb/ext/history.rb

@@ -0,0 +1,90 @@
+module IRB
+  # The util methods, history and history!, were taken from Ben Bleything's
+  # command_history.rb in utility_belt.
+  class 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
+      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.read(self.class.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
+      
+      # 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
+    
+    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
+    end
+  end
+end
+
+module Kernel
+  def history(number_of_entries = IRB::History.max_entries_in_overview)
+    IRB::History.current.history(number_of_entries)
+    nil
+  end
+  alias_method :h, :history
+  
+  def history!(entry_or_range)
+    IRB::History.current.history!(entry_or_range)
+    nil
+  end
+  alias_method :h!, :history!
+  
+  def clear_history!
+    IRB::History.current.clear!
+    nil
+  end
+end
+
+IRB::Context.processors << IRB::History
+IRB::History.file = File.expand_path("~/.irb_history")
+IRB::History.max_entries_in_overview = 50

data/lib/irb/formatter.rb

@@ -1,12 +1,13 @@
 module IRB
-  def self.formatter
-    @formatter ||= Formatter.new
+  class << self
+    attr_accessor :formatter
   end
   
   class Formatter
     DEFAULT_PROMPT = "irb(%s):%03d:%d> "
     SIMPLE_PROMPT  = ">> "
     NO_PROMPT      = ""
+    RESULT_PREFIX  = "=>"
     SYNTAX_ERROR   = "SyntaxError: compile error\n(irb):%d: %s"
     SOURCE_ROOT    = /^#{File.expand_path('../../../', __FILE__)}/
     
@@ -27,8 +28,12 @@ module IRB
       end
     end
     
+    def inspect_object(object)
+      object.respond_to?(:pretty_inspect) ? object.pretty_inspect : object.inspect
+    end
+    
     def result(object)
-      "=> #{object.inspect}"
+      "#{RESULT_PREFIX} #{inspect_object(object)}"
     end
     
     def syntax_error(line, message)
@@ -46,4 +51,6 @@ module IRB
       end
     end
   end
-end
+end
+
+IRB.formatter = IRB::Formatter.new

data/lib/irb.rb

@@ -1,15 +1,8 @@
 require 'irb/context'
 require 'irb/source'
 
+require 'irb/ext/history'
+
 if !ENV['SPECCING'] && defined?(RUBY_ENGINE) && RUBY_ENGINE == "macruby"
   require 'irb/ext/macruby'
 end
-
-module Kernel
-  # Creates a new IRB::Context with the given +object+ and runs it.
-  def irb(object, binding = nil)
-    IRB::Context.new(object, binding).run
-  end
-  
-  private :irb
-end

data/spec/colorize_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'irb/ext/colorize'
+
+main = self
+  
+describe "IRB::ColoredFormatter" do
+  before do
+    @formatter = IRB::ColoredFormatter.new
+    @context = IRB::Context.new(main)
+  end
+  
+  it "colorizes a constant" do
+    @formatter.result(Hash).should == "=> \e[1;32mHash\e[0;0m"
+  end
+  
+  # Not Wirble compliant
+  it "colorizes a Range" do
+    # @formatter.result(1..3).should == "=> \e[0;36m1\e[0;0m\e[0;31m..\e[0;0m\e[0;36m3\e[0;0m"
+    @formatter.result(1..3).should == "=> \e[0;36m1\e[0;0m\e[0;34m..\e[0;0m\e[0;36m3\e[0;0m"
+  end
+  
+  it "colorizes a String" do
+    @formatter.result("foo bar").should == "=> \e[0;31m\"\e[0;0m\e[0;36mfoo bar\e[0;0m\e[0;31m\"\e[0;0m"
+  end
+  
+  it "colorizes a Hash" do
+    @formatter.result(:ok => :foo).should == "=> \e[0;32m{\e[0;0m\e[1;33m:\e[0;0m\e[1;33mok\e[0;0m\e[0;34m=>\e[0;0m\e[1;33m:\e[0;0m\e[1;33mfoo\e[0;0m\e[0;32m}\e[0;0m"
+  end
+  
+  it "colorizes an Array" do
+    @formatter.result([1, 2]).should == "=> \e[0;32m[\e[0;0m\e[0;36m1\e[0;0m\e[0;34m,\e[0;0m \e[0;36m2\e[0;0m\e[0;32m]\e[0;0m"
+  end
+  
+  it "colorizes the prompt" do
+    @formatter.colors[:prompt] = :light_green
+    @formatter.prompt(@context).should == "\e[1;32m#{IRB::Formatter.new.prompt(@context)}\e[0;0m"
+  end
+  
+  it "colorizes the result prefix" do
+    @formatter.colors[:result_prefix] = :light_red
+    @formatter.result("").should == "\e[1;31m=>\e[0;0m \e[0;31m\"\e[0;0m\e[0;31m\"\e[0;0m"
+  end
+  
+  it "uses the dark_background color scheme by default" do
+    @formatter.color_scheme.should == :dark_background
+  end
+  
+  it "changes color scheme" do
+    @formatter.color_scheme = :fresh
+    @formatter.color_scheme.should == :fresh
+    @formatter.colors[:result_prefix].should == :light_purple
+  end
+end

data/spec/context_spec.rb

@@ -17,6 +17,12 @@ def stub_Readline
 end
 stub_Readline
 
+class TestProcessor
+  def input(s)
+    s * 2
+  end
+end
+
 main = self
 
 describe "IRB::Context" do
@@ -44,6 +50,17 @@ describe "IRB::Context" do
     @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
@@ -62,8 +79,8 @@ end
 describe "IRB::Context, when evaluating source" do
   before do
     @context = IRB::Context.new(main)
-    def @context.puts(string); @printed = string; end
-    def @context.printed;      @printed;          end
+    def @context.printed;      @printed ||= ''          end
+    def @context.puts(string); printed << "#{string}\n" end
   end
   
   it "evaluates code with the object's binding" do
@@ -72,8 +89,7 @@ describe "IRB::Context, when evaluating source" do
   
   it "prints the result" do
     @context.evaluate("Hash[:foo, :foo]")
-    printed = @context.instance_variable_get(:@printed)
-    printed.should == "=> {:foo=>:foo}"
+    @context.printed.should == "=> {:foo=>:foo}\n"
   end
   
   it "assigns the result to the local variable `_'" do
@@ -108,6 +124,12 @@ describe "IRB::Context, when evaluating source" do
     @context.process_line("end")
     @context.printed.should.match /\(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
+  end
 end
 
 describe "IRB::Context, when receiving input" do
@@ -121,6 +143,12 @@ describe "IRB::Context, when receiving input" do
     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
@@ -196,4 +224,13 @@ describe "IRB::Context, when receiving input" do
     @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
+  end
 end

data/spec/formatter_spec.rb

@@ -54,6 +54,12 @@ describe "IRB::Formatter" do
     @formatter.result(:foo => :foo).should == "=> {:foo=>:foo}"
   end
   
+  it "prints the result with object#pretty_inspect, if it responds to it" do
+    object = Object.new
+    def object.pretty_inspect; "foo"; end
+    @formatter.result(object).should == "foo"
+  end
+  
   it "prints that a syntax error occurred on the last line and reset the buffer to the previous line" do
     @formatter.syntax_error(2, "syntax error, unexpected '}'").should ==
       "SyntaxError: compile error\n(irb):2: syntax error, unexpected '}'"

data/spec/history_spec.rb

@@ -0,0 +1,171 @@
+require File.expand_path('../spec_helper', __FILE__)
+require "tempfile"
+
+describe "IRB::History" do
+  it "stores the history by default in ~/.irb_history" do
+    IRB::History.file.should == File.expand_path("~/.irb_history")
+  end
+  
+  before do
+    @file = Tempfile.new("irb_history.txt")
+    IRB::History.file = @file.path
+    @history = IRB::History.new(nil)
+  end
+  
+  after do
+    @file.close
+  end
+  
+  it "adds input to the history file" do
+    @history.input "puts :ok"
+    @file.rewind; @file.read.should == "puts :ok\n"
+    @history.input "foo(x)"
+    @file.rewind; @file.read.should == "puts :ok\nfoo(x)\n"
+  end
+  
+  it "returns the same input value" do
+    @history.input("foo(x)").should == "foo(x)"
+  end
+  
+  it "returns the contents of the history file as an array of lines" do
+    @history.input "puts :ok"
+    @history.to_a.should == ["puts :ok"]
+    @history.input "foo(x)"
+    @history.to_a.should == ["puts :ok", "foo(x)"]
+  end
+  
+  it "stores the contents of the history file in Readline::HISTORY once" do
+    Readline::HISTORY.clear
+    
+    @history.input "puts :ok"
+    @history.input "foo(x)"
+    
+    IRB::History.new(nil)
+    IRB::History.new(nil)
+    
+    Readline::HISTORY.to_a.should == ["puts :ok", "foo(x)"]
+  end
+  
+  it "clears the history and history file" do
+    @history.input "puts :ok"
+    @history.input "foo(x)"
+    @history.clear!
+    
+    @file.rewind; @file.read.should.be.empty
+    Readline::HISTORY.to_a.should.be.empty
+  end
+end
+
+class IRB::History
+  def printed
+    @printed ||= ""
+  end
+  
+  def print(s)
+    printed << s
+  end
+  
+  def puts(s)
+    printed << "#{s}\n"
+  end
+  
+  def clear!
+    @cleared = true
+  end
+  def cleared?
+    @cleared
+  end
+end
+
+describe "IRB::History, concerning the user api" do
+  it "shows by default a maximum of 50 history entries" do
+    IRB::History.max_entries_in_overview.should == 50
+  end
+  
+  before do
+    sources = [
+      "puts :ok",
+      "x = foo(x)",
+      "class AAA",
+      "  def bar",
+      "    :ok",
+      "  end",
+      "end",
+      "THIS LINE REPRESENTS THE ENTERED COMMAND AND SHOULD BE OMITTED!"
+    ]
+    
+    Readline::HISTORY.clear
+    sources.each { |source| Readline::HISTORY.push(source) }
+    
+    IRB::History.max_entries_in_overview = 5
+    
+    @context = IRB::Context.new(Object.new)
+    IRB::Context.current = @context
+    
+    @history = @context.processors.find { |p| p.is_a?(IRB::History) }
+  end
+  
+  after do
+    IRB::Context.current = nil
+  end
+  
+  it "returns nil so that IRB doesn't cache some arbitrary line number" do
+    history.should == nil
+  end
+  
+  it "prints a formatted list with, by default IRB::History.max_entries_in_overview, number of history entries" do
+    history
+    
+    @history.printed.should == %{
+2: class AAA
+3:   def bar
+4:     :ok
+5:   end
+6: end
+}.sub(/\n/, '')
+  end
+  
+  it "prints a formatted list of N most recent history entries" do
+    history(7)
+    
+    @history.printed.should == %{
+0: puts :ok
+1: x = foo(x)
+2: class AAA
+3:   def bar
+4:     :ok
+5:   end
+6: end
+}.sub(/\n/, '')
+  end
+  
+  it "prints a formatted list of all history entries if the request number of entries is more than there is" do
+    history(777)
+
+    @history.printed.should == %{
+0: puts :ok
+1: x = foo(x)
+2: class AAA
+3:   def bar
+4:     :ok
+5:   end
+6: end
+}.sub(/\n/, '')
+  end
+  
+  it "evaluates the history entry specified" do
+    @context.__evaluate__("x = 2; def foo(x); x * 2; end")
+    history! 1
+    @context.__evaluate__("x").should == 4
+  end
+  
+  it "evaluates the history entries specified by a range" do
+    history! 2..6
+    @context.__evaluate__("AAA.new.bar").should == :ok
+  end
+  
+  it "clears the history and history file" do
+    clear_history!
+    @history.should.be.cleared
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dietrb
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Eloy Duran
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-24 00:00:00 +01:00
+date: 2010-04-18 00:00:00 +02:00
 default_executable: dietrb
 dependencies: []
 
@@ -22,24 +22,29 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- TODO
 files: 
 - .gitignore
 - LICENSE
 - README.rdoc
 - Rakefile
+- TODO
 - VERSION
 - bin/dietrb
 - dietrb.gemspec
 - lib/irb.rb
 - lib/irb/context.rb
+- lib/irb/ext/colorize.rb
 - lib/irb/ext/completion.rb
+- lib/irb/ext/history.rb
 - lib/irb/ext/macruby.rb
 - lib/irb/formatter.rb
 - lib/irb/source.rb
+- spec/colorize_spec.rb
 - spec/completion_spec.rb
 - spec/context_spec.rb
 - spec/formatter_spec.rb
-- spec/irb_spec.rb
+- spec/history_spec.rb
 - spec/source_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -71,9 +76,10 @@ signing_key:
 specification_version: 3
 summary: IRB on a diet, for MacRuby / Ruby 1.9
 test_files: 
+- spec/colorize_spec.rb
 - spec/completion_spec.rb
 - spec/context_spec.rb
 - spec/formatter_spec.rb
-- spec/irb_spec.rb
+- spec/history_spec.rb
 - spec/source_spec.rb
 - spec/spec_helper.rb

data/spec/irb_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-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
-  end
-end