pry 0.9.3pre1-i386-mingw32 → 0.9.4-i386-mingw32

data/test/test_command_processor.rb

@@ -18,18 +18,6 @@ describe "Pry::CommandProcessor" do
 
     valid = @command_processor.valid_command? "blah"
     valid.should == false
-
-
-    a = "test-command"
-
-    # not passing in a binding so 'a' shouldn't exist and no command
-    # will be matched
-    valid = @command_processor.valid_command?('#{a}')
-    valid.should == false
-
-    # passing in the optional binding (against which interpolation is performed)
-    valid = @command_processor.valid_command? '#{a}', binding
-    valid.should == true
   end
 
   it 'should correctly match a simple string command' do
@@ -168,88 +156,21 @@ describe "Pry::CommandProcessor" do
     pos.should == sample_text.size
   end
 
-  it 'should correctly match a command whose name is interpolated' do
-    @pry.commands.command("blah") {}
-    a = "bl"
-    b = "ah"
-    command, captures, pos = @command_processor.command_matched '#{a}#{b}', binding
-
-    command.name.should == "blah"
-    captures.should == []
-    pos.should == command.name.length
-  end
-
-  it 'should correctly match a regex command and interpolation should not break the regex' do
-    regex_command_name = /blah(\d)/
-    @pry.commands.command(regex_command_name) {}
-
-    sample_text = "blah5"
-    a = "5"
-    command, captures, pos = @command_processor.command_matched 'blah#{a}', binding
-
-    command.name.should == regex_command_name
-    captures.should == ["5"]
-    pos.should == sample_text.size
-  end
-
-  it 'should NOT match a regex command that is interpolated when :interpolate => false' do
-    regex_command_name = /blah(\d)/
-    @pry.commands.command(regex_command_name, "", :interpolate => false) {}
-
-    sample_text = "blah5"
-    a = "5"
-    command, captures, pos = @command_processor.command_matched 'blah#{a}', binding
-
-    command.should == nil
-  end
-
-  it 'should correctly match a regex command and interpolation should not break the regex where entire regex command is interpolated' do
-    regex_command_name = /blah(\d)/
-    @pry.commands.command(regex_command_name) {}
-
-    sample_text = "blah5"
-    a = "bl"
-    b = "ah"
-    c = "5"
-
-    command, captures, pos = @command_processor.command_matched '#{a}#{b}#{c}', binding
-
-    command.name.should == regex_command_name
-    captures.should == ["5"]
-    pos.should == sample_text.size
-  end
-
-  it 'should NOT match a regex command where entire regex command is interpolated and :interpolate => false' do
-    regex_command_name = /blah(\d)/
-    @pry.commands.command(regex_command_name, "", :interpolate => false) {}
-
-    sample_text = "blah5"
-    a = "bl"
-    b = "ah"
-    c = "5"
-
-    command, captures, pos = @command_processor.command_matched '#{a}#{b}#{c}', binding
-    command.should == nil
-  end
-
-  it 'should NOT match a command whose name is interpolated when :interpolate => false' do
+  it 'should not interpolate commands that have :interpolate => false (interpolate_string should *not* be called)' do
     @pry.commands.command("boast", "", :interpolate => false) {}
-    a = "boa"
-    b = "st"
 
     # remember to use '' instead of "" when testing interpolation or
     # you'll cause yourself incredible confusion
-    command, captures, pos = @command_processor.command_matched '#{a}#{b}', binding
-
-    command.should == nil
+    lambda { @command_processor.command_matched('boast #{c}', binding) }.should.not.raise NameError
   end
 
+  it 'should only execute the contents of an interpolation once' do
+    $obj = 'a'
 
-  it 'commands that have :interpolate => false should not be interpolated (interpolate_string should *not* be called)' do
-    @pry.commands.command("boast", "", :interpolate => false) {}
+    redirect_pry_io(InputTester.new('cat #{$obj.succ!}'), StringIO.new) do
+      Pry.new.rep
+    end
 
-    # remember to use '' instead of "" when testing interpolation or
-    # you'll cause yourself incredible confusion
-    lambda { @command_processor.command_matched('boast #{c}', binding) }.should.not.raise NameError
+    $obj.should == 'b'
   end
 end

data/test/test_command_set.rb

@@ -112,9 +112,9 @@ describe Pry::CommandSet do
     @set.commands['foo'].description.should == 'baz'
   end
 
-  it 'should return nil for commands by default' do
+  it 'should return Pry::CommandContext::VOID_VALUE for commands by default' do
     @set.command('foo') { 3 }
-    @set.run_command(nil, 'foo').should == nil
+    @set.run_command(nil, 'foo').should == Pry::CommandContext::VOID_VALUE
   end
 
   it 'should be able to keep return values' do
@@ -122,6 +122,11 @@ describe Pry::CommandSet do
     @set.run_command(nil, 'foo').should == 3
   end
 
+  it 'should be able to keep return values, even if return value is nil' do
+    @set.command('foo', '', :keep_retval => true) { nil }
+    @set.run_command(nil, 'foo').should == nil
+  end
+
   it 'should be able to have its own helpers' do
     @set.command('foo') do
       should.respond_to :my_helper
@@ -187,4 +192,37 @@ describe Pry::CommandSet do
     @set.command 'foo', "", :listing => 'bar' do;end
     @set.commands['foo'].options[:listing].should == 'bar'
   end
+
+  it "should provide a 'help' command" do
+    context = Pry::CommandContext.new
+    context.command_set = @set
+    context.output = StringIO.new
+
+    lambda {
+      @set.run_command(context, 'help')
+    }.should.not.raise
+  end
+
+  it "should sort the output of the 'help' command" do
+    @set.command 'foo', "Fooerizes" do; end
+    @set.command 'goo', "Gooerizes" do; end
+    @set.command 'moo', "Mooerizes" do; end
+    @set.command 'boo', "Booerizes" do; end
+
+    context = Pry::CommandContext.new
+    context.command_set = @set
+    context.output = StringIO.new
+
+    @set.run_command(context, 'help')
+
+    doc = context.output.string
+
+    order = [doc.index("boo"),
+             doc.index("foo"),
+             doc.index("goo"),
+             doc.index("help"),
+             doc.index("moo")]
+
+    order.should == order.sort
+  end
 end

data/test/test_completion.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+describe Pry::InputCompleter do
+
+  before do
+    # The AMQP gem has some classes like this:
+    #  pry(main)> AMQP::Protocol::Test::ContentOk.name
+    #  => :content_ok
+    module SymbolyName
+      def self.name; :symboly_name; end
+    end
+  end
+
+  after do
+    Object.remove_const :SymbolyName
+  end
+
+  # another jruby hack :((
+  if !jruby?
+    it "should not crash if there's a Module that has a symbolic name." do
+      completer = Pry::InputCompleter.build_completion_proc(Pry.binding_for(Object.new))
+      lambda{ completer.call "a.to_s." }.should.not.raise Exception
+    end
+  end
+end
+

data/test/test_default_commands/test_context.rb

@@ -1,6 +1,104 @@
 require 'helper'
 
 describe "Pry::DefaultCommands::Context" do
+  describe "exit-all" do
+    it 'should break out of the repl loop of Pry instance (returning target of session)' do
+      redirect_pry_io(InputTester.new("exit-all"), StringIO.new) do
+        Pry.new.repl(0).should == 0
+      end
+    end
+
+    it 'should break out of the repl loop of Pry instance wth a user specified value' do
+      redirect_pry_io(InputTester.new("exit-all 'message'"), StringIO.new) do
+        Pry.new.repl(0).should == 'message'
+      end
+    end
+
+    it 'should break of the repl loop even if multiple bindings still on stack' do
+      ins = nil
+      redirect_pry_io(InputTester.new("cd 1", "cd 2", "exit-all 'message'"), StringIO.new) do
+        ins = Pry.new.tap { |v| v.repl(0).should == 'message' }
+      end
+    end
+
+    it 'binding_stack should be empty after breaking out of the repl loop' do
+      ins = nil
+      redirect_pry_io(InputTester.new("cd 1", "cd 2", "exit-all"), StringIO.new) do
+        ins = Pry.new.tap { |v| v.repl(0) }
+      end
+
+      ins.binding_stack.empty?.should == true
+    end
+  end
+
+  describe "exit" do
+    it 'should pop a binding with exit' do
+      b = Pry.binding_for(:outer)
+      b.eval("x = :inner")
+
+      redirect_pry_io(InputTester.new("cd x", "$inner = self;", "exit", "$outer = self", "exit-all"), StringIO.new) do
+        b.pry
+      end
+      $inner.should == :inner
+      $outer.should == :outer
+    end
+
+    it 'should break out of the repl loop of Pry instance when binding_stack has only one binding with exit' do
+      Pry.start(0, :input => StringIO.new("exit")).should == 0
+    end
+
+    it 'should break out of the repl loop of Pry instance when binding_stack has only one binding with exit, and return user-given value' do
+      Pry.start(0, :input => StringIO.new("exit :john")).should == :john
+    end
+  end
+
+  describe "jump-to" do
+    it 'should jump to the proper binding index in the stack' do
+      outp = StringIO.new
+      redirect_pry_io(InputTester.new("cd 1", "cd 2", "jump-to 1", "$blah = self", "exit-all"), outp) do
+        Pry.start(0)
+      end
+
+      $blah.should == 1
+    end
+
+    it 'should print error when trying to jump to a non-existent binding index' do
+      outp = StringIO.new
+      redirect_pry_io(InputTester.new("cd 1", "cd 2", "jump-to 100", "exit-all"), outp) do
+        Pry.start(0)
+      end
+
+      outp.string.should =~ /Invalid nest level/
+    end
+
+    it 'should print error when trying to jump to the same binding index' do
+      outp = StringIO.new
+      redirect_pry_io(InputTester.new("cd 1", "cd 2", "jump-to 2", "exit-all"), outp) do
+        Pry.new.repl(0)
+      end
+
+      outp.string.should =~ /Already/
+    end
+  end
+
+  describe "exit-program" do
+    it 'should raise SystemExit' do
+      redirect_pry_io(InputTester.new("exit-program"), StringIO.new) do
+        lambda { Pry.new.repl(0).should == 0 }.should.raise SystemExit
+      end
+    end
+
+    it 'should exit the program with the provided value' do
+      redirect_pry_io(InputTester.new("exit-program 66"), StringIO.new) do
+        begin
+          Pry.new.repl(0)
+        rescue SystemExit => e
+          e.status.should == 66
+        end
+      end
+    end
+  end
+
   describe "cd" do
     after do
       $obj = nil
@@ -28,6 +126,10 @@ describe "Pry::DefaultCommands::Context" do
       $outer.should == :outer
     end
 
+    it 'should break out of the repl loop of Pry instance when binding_stack has only one binding with cd ..' do
+      Pry.start(0, :input => StringIO.new("cd ..")).should == 0
+    end
+
     it 'should break out to outer-most session with cd /' do
       b = Pry.binding_for(:outer)
       b.eval("x = :inner")
@@ -40,9 +142,91 @@ describe "Pry::DefaultCommands::Context" do
       $outer.should == :outer
     end
 
-    it 'should start a session on TOPLEVEL_BINDING with cd ::' do
+    it 'should break out to outer-most session with just cd (no args)' do
       b = Pry.binding_for(:outer)
+      b.eval("x = :inner")
+
+      redirect_pry_io(InputTester.new("cd x", "$inner = self;", "cd 5", "$five = self", "cd", "$outer = self", "exit-all"), StringIO.new) do
+        b.pry
+      end
+      $inner.should == :inner
+      $five.should == 5
+      $outer.should == :outer
+    end
+
+    it 'should cd into an object and its ivar using cd obj/@ivar syntax' do
+      $obj = Object.new
+      $obj.instance_variable_set(:@x, 66)
+
+      redirect_pry_io(InputTester.new("cd $obj/@x", "$result = _pry_.binding_stack.dup", "exit-all"), StringIO.new) do
+        Pry.start
+      end
+      $result.size.should == 3
+      $result[1].eval('self').should == $obj
+      $result[2].eval('self').should == 66
+    end
 
+    it 'should cd into an object and its ivar using cd obj/@ivar/ syntax (note following /)' do
+      $obj = Object.new
+      $obj.instance_variable_set(:@x, 66)
+
+      redirect_pry_io(InputTester.new("cd $obj/@x/", "$result = _pry_.binding_stack.dup", "exit-all"), StringIO.new) do
+        Pry.start
+      end
+      $result.size.should == 3
+      $result[1].eval('self').should == $obj
+      $result[2].eval('self').should == 66
+    end
+
+    it 'should cd into previous object and its local using cd ../local syntax' do
+      $obj = Object.new
+      $obj.instance_variable_set(:@x, 66)
+
+      redirect_pry_io(InputTester.new("cd $obj", "local = :local", "cd @x", "cd ../local", "$result = _pry_.binding_stack.dup", "exit-all"), StringIO.new) do
+        Pry.start
+      end
+      $result.size.should == 3
+      $result[1].eval('self').should == $obj
+      $result[2].eval('self').should == :local
+    end
+
+    it 'should cd into an object and its ivar and back again using cd obj/@ivar/.. syntax' do
+      $obj = Object.new
+      $obj.instance_variable_set(:@x, 66)
+
+      redirect_pry_io(InputTester.new("cd $obj/@x/..", "$result = _pry_.binding_stack.dup", "exit-all"), StringIO.new) do
+        Pry.start
+      end
+      $result.size.should == 2
+      $result[1].eval('self').should == $obj
+    end
+
+    it 'should cd into an object and its ivar and back and then into another ivar using cd obj/@ivar/../@y syntax' do
+      $obj = Object.new
+      $obj.instance_variable_set(:@x, 66)
+      $obj.instance_variable_set(:@y, 79)
+
+      redirect_pry_io(InputTester.new("cd $obj/@x/../@y", "$result = _pry_.binding_stack.dup", "exit-all"), StringIO.new) do
+        Pry.start
+      end
+      $result.size.should == 3
+      $result[1].eval('self').should == $obj
+      $result[2].eval('self').should == 79
+    end
+
+    it 'should cd back to top-level and then into another ivar using cd /@ivar/ syntax' do
+      $obj = Object.new
+      $obj.instance_variable_set(:@x, 66)
+      TOPLEVEL_BINDING.eval('@z = 20')
+
+      redirect_pry_io(InputTester.new("cd $obj/@x/", "cd /@z", "$result = _pry_.binding_stack.dup", "exit-all"), StringIO.new) do
+        Pry.start
+      end
+      $result.size.should == 2
+      $result[1].eval('self').should == 20
+    end
+
+    it 'should start a session on TOPLEVEL_BINDING with cd ::' do
       redirect_pry_io(InputTester.new("cd ::", "$obj = self", "exit-all"), StringIO.new) do
         5.pry
       end

data/test/test_default_commands/test_documentation.rb

@@ -10,6 +10,16 @@ describe "Pry::DefaultCommands::Documentation" do
 
       str_output.string.should =~ /sample doc/
     end
+    
+    it 'should output multiple methods\' documentation' do
+      str_output = StringIO.new
+      redirect_pry_io(InputTester.new("show-doc sample_method another_sample_method", "exit-all"), str_output) do
+        pry
+      end
+
+      str_output.string.should =~ /sample doc/
+      str_output.string.should =~ /another sample doc/
+    end
 
     it 'should output a method\'s documentation if inside method without needing to use method name' do
       $str_output = StringIO.new

data/test/test_default_commands/test_input.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 describe "Pry::DefaultCommands::Input" do
 
-  describe "amend-line-N" do
+  describe "amend-line" do
     it 'should correctly amend the last line of input when no line number specified ' do
       str_output = StringIO.new
       redirect_pry_io(InputTester.new("def hello", "puts :bing", "amend-line puts :blah", "show-input", "exit-all"), str_output) do
@@ -104,7 +104,7 @@ describe "Pry::DefaultCommands::Input" do
 
     it 'should correctly amend the specified range of lines, using negative numbers in range' do
       str_output = StringIO.new
-      redirect_pry_io(InputTester.new("def hello", "puts :bing", "puts :bang", "puts :boast", "puts :heart", "amend-line-2..-2 puts :bong", "show-input", "exit-all"), str_output) do
+      redirect_pry_io(InputTester.new("def hello", "puts :bing", "puts :bang", "puts :boast", "puts :heart", "amend-line 2..-2 puts :bong", "show-input", "exit-all"), str_output) do
         pry
       end
       str_output.string.should =~ /\d+: def hello\n\d+: puts :bong\n\d+: puts :heart/
@@ -150,19 +150,24 @@ describe "Pry::DefaultCommands::Input" do
   end
 
   describe "play" do
-    it 'should play a string of code (with no args)' do
-      redirect_pry_io(InputTester.new("play :test_string", "exit-all"), str_output = StringIO.new) do
-        pry
+    it 'should play a string variable  (with no args)' do
+      b = binding
+      b.eval('x = "\"hello\""')
+      redirect_pry_io(InputTester.new("play x", "exit-all"), str_output = StringIO.new) do
+        Pry.start b, :hooks => {}
       end
-      str_output.string.should =~ /:test_string/
+      str_output.string.should =~ /hello/
     end
 
-    it 'should play an interpolated string of code (with no args)' do
-      $obj = ":test_string_interpolated"
-      redirect_pry_io(InputTester.new('play #{$obj}', "exit-all"), str_output = StringIO.new) do
-        pry
+    it 'should play a string variable  (with no args) using --lines to select what to play' do
+      b = binding
+      b.eval('x = "\"hello\"\n\"goodbye\"\n\"love\""')
+      redirect_pry_io(InputTester.new("play x --lines 1", "exit-all"), str_output = StringIO.new) do
+        Pry.start b, :hooks => {}
       end
-      str_output.string.should =~ /:test_string_interpolated/
+      str_output.string.should =~ /hello/
+      str_output.string.should.not =~ /love/
+      str_output.string.should.not =~ /goodbye/
     end
 
     it 'should play a method with the -m switch (a single line)' do
@@ -202,8 +207,8 @@ describe "Pry::DefaultCommands::Input" do
     end
 
     before do
-      Readline::HISTORY.shift until Readline::HISTORY.empty?
-      @hist = Readline::HISTORY
+      Pry.history.clear
+      @hist = Pry.history
     end
 
     it 'should display the correct history' do
@@ -321,6 +326,27 @@ describe "Pry::DefaultCommands::Input" do
       str_output.string.each_line.count.should == 4
       str_output.string.should =~ /b\n\d+:.*c\n\d+:.*d/
     end
+
+    it "should not contain duplicated lines" do
+      str_output = StringIO.new
+      redirect_pry_io(InputTester.new("3", "_ += 1", "_ += 1", "hist", "exit-all", :history => @hist), str_output) do
+        pry
+      end
+
+      str_output.string.each_line.grep(/_ \+= 1/).count.should == 1
+    end
+
+    it "should not contain duplicated lines" do
+      str_output = StringIO.new
+      redirect_pry_io(InputTester.new(":place_holder", "2 + 2", "", "", "3 + 3", "hist", "exit-all", :history => @hist), str_output) do
+        pry
+      end
+
+      a = str_output.string.each_line.to_a.index{|line| line.include?("2 + 2") }
+      b = str_output.string.each_line.to_a.index{|line| line.include?("3 + 3") }
+
+      (a + 1).should == b
+    end
   end