pry 0.9.7.4-i386-mingw32 → 0.9.8-i386-mingw32

data/test/test_command_set.rb

@@ -3,7 +3,10 @@ require 'helper'
 describe Pry::CommandSet do
   before do
     @set = Pry::CommandSet.new
-    @ctx = Pry::CommandContext.new
+    @ctx = {
+      :target => binding,
+      :command_set => @set
+    }
   end
 
   it 'should call the block used for the command when it is called' do
@@ -24,11 +27,11 @@ describe Pry::CommandSet do
     @set.run_command @ctx, 'foo', 1, 2, 3
   end
 
-  it 'should use the first argument as self' do
+  it 'should use the first argument as context' do
     ctx = @ctx
 
     @set.command 'foo' do
-      self.should == ctx
+      self.context.should == ctx
     end
 
     @set.run_command @ctx, 'foo'
@@ -50,6 +53,15 @@ describe Pry::CommandSet do
     }.should.raise(Pry::NoCommandError)
   end
 
+  it 'should be able to remove its own commands, by listing name' do
+    @set.command(/^foo1/, 'desc', :listing => 'foo') {}
+    @set.delete 'foo'
+
+    lambda {
+      @set.run_command @ctx, /^foo1/
+    }.should.raise(Pry::NoCommandError)
+  end
+
   it 'should be able to import some commands from other sets' do
     run = false
 
@@ -68,6 +80,19 @@ describe Pry::CommandSet do
     }.should.raise(Pry::NoCommandError)
   end
 
+  it 'should be able to import some commands from other sets using listing name' do
+    run = false
+
+    other_set = Pry::CommandSet.new do
+      command(/^foo1/, 'desc', :listing => 'foo') { run = true }
+    end
+
+    @set.import_from(other_set, 'foo')
+
+    @set.run_command @ctx, /^foo1/
+    run.should == true
+  end
+
   it 'should be able to import a whole set' do
     run = []
 
@@ -108,16 +133,38 @@ describe Pry::CommandSet do
     run.should == true
   end
 
-  it 'should be able to change the descritpions of methods' do
+  it "should be able to alias a method by the command's listing name" do
+    run = false
+    @set.command(/^foo1/, 'stuff', :listing => 'foo') { run = true }
+
+    @set.alias_command 'bar', 'foo'
+    @set.commands['bar'].name.should == 'bar'
+    @set.commands['bar'].description.should == ''
+
+    @set.run_command @ctx, 'bar'
+    run.should == true
+  end
+
+  it 'should be able to change the descriptions of commands' do
     @set.command('foo', 'bar') {}
     @set.desc 'foo', 'baz'
 
     @set.commands['foo'].description.should == 'baz'
   end
 
-  it 'should return Pry::CommandContext::VOID_VALUE for commands by default' do
+  it 'should get the descriptions of commands' do
+    @set.command('foo', 'bar') {}
+    @set.desc('foo').should == 'bar'
+  end
+
+  it 'should get the descriptions of commands, by listing' do
+    @set.command(/^foo1/, 'bar', :listing => 'foo') {}
+    @set.desc('foo').should == 'bar'
+  end
+
+  it 'should return Pry::Command::VOID_VALUE for commands by default' do
     @set.command('foo') { 3 }
-    @set.run_command(@ctx, 'foo').should == Pry::CommandContext::VOID_VALUE
+    @set.run_command(@ctx, 'foo').should == Pry::Command::VOID_VALUE
   end
 
   it 'should be able to keep return values' do
@@ -140,7 +187,7 @@ describe Pry::CommandSet do
     end
 
     @set.run_command(@ctx, 'foo')
-    Pry::CommandContext.new.should.not.respond_to :my_helper
+    Pry::Command.subclass('foo', '', {}, Module.new).new({:target => binding}).should.not.respond_to :my_helper
   end
 
   it 'should not recreate a new helper module when helpers is called' do
@@ -197,8 +244,8 @@ describe Pry::CommandSet do
   end
 
   it "should provide a 'help' command" do
-    @ctx.command_set = @set
-    @ctx.output = StringIO.new
+    @ctx[:command_set] = @set
+    @ctx[:output] = StringIO.new
 
     lambda {
       @set.run_command(@ctx, 'help')
@@ -211,12 +258,12 @@ describe Pry::CommandSet do
     @set.command 'moo', "Mooerizes" do; end
     @set.command 'boo', "Booerizes" do; end
 
-    @ctx.command_set = @set
-    @ctx.output = StringIO.new
+    @ctx[:command_set] = @set
+    @ctx[:output] = StringIO.new
 
     @set.run_command(@ctx, 'help')
 
-    doc = @ctx.output.string
+    doc = @ctx[:output].string
 
     order = [doc.index("boo"),
              doc.index("foo"),
@@ -226,4 +273,283 @@ describe Pry::CommandSet do
 
     order.should == order.sort
   end
+
+  describe "renaming a command" do
+    it 'should be able to rename and run a command' do
+      run = false
+      @set.command('foo') { run = true }
+      @set.rename_command('bar', 'foo')
+      @set.run_command(@ctx, 'bar')
+      run.should == true
+    end
+
+    it 'should accept listing name when renaming a command' do
+      run = false
+      @set.command('foo', "", :listing => 'love') { run = true }
+      @set.rename_command('bar', 'love')
+      @set.run_command(@ctx, 'bar')
+      run.should == true
+    end
+
+    it 'should raise exception trying to rename non-existent command' do
+      lambda { @set.rename_command('bar', 'foo') }.should.raise ArgumentError
+    end
+
+    it 'should make old command name inaccessible' do
+      @set.command('foo') { }
+      @set.rename_command('bar', 'foo')
+      lambda { @set.run_command(@ctx, 'foo') }.should.raise Pry::NoCommandError
+    end
+
+
+    it 'should be able to pass in options when renaming command' do
+      desc    = "hello"
+      listing = "bing"
+      @set.command('foo') { }
+      @set.rename_command('bar', 'foo', :description => desc, :listing => listing, :keep_retval => true)
+      @set.commands['bar'].description.should           == desc
+      @set.commands['bar'].options[:listing].should     == listing
+      @set.commands['bar'].options[:keep_retval].should == true
+    end
+  end
+
+  describe "command decorators - before_command and after_command" do
+    describe "before_command" do
+      it 'should be called before the original command' do
+        foo = []
+        @set.command('foo') { foo << 1 }
+        @set.before_command('foo') { foo << 2 }
+        @set.run_command(@ctx, 'foo')
+
+        foo.should == [2, 1]
+      end
+
+      it 'should be called before the original command, using listing name' do
+        foo = []
+        @set.command(/^foo1/, '', :listing => 'foo') { foo << 1 }
+        @set.before_command('foo') { foo << 2 }
+        @set.run_command(@ctx, /^foo1/)
+
+        foo.should == [2, 1]
+      end
+
+      it 'should share the context with the original command' do
+        @ctx[:target] = "test target string".__binding__
+        before_val  = nil
+        orig_val    = nil
+        @set.command('foo') { orig_val = target }
+        @set.before_command('foo') { before_val = target }
+        @set.run_command(@ctx, 'foo')
+
+        before_val.should == @ctx[:target]
+        orig_val.should == @ctx[:target]
+      end
+
+      it 'should work when applied multiple times' do
+        foo = []
+        @set.command('foo') { foo << 1 }
+        @set.before_command('foo') { foo << 2 }
+        @set.before_command('foo') { foo << 3 }
+        @set.before_command('foo') { foo << 4 }
+        @set.run_command(@ctx, 'foo')
+
+        foo.should == [4, 3, 2, 1]
+      end
+
+    end
+
+    describe "after_command" do
+      it 'should be called after the original command' do
+        foo = []
+        @set.command('foo') { foo << 1 }
+        @set.after_command('foo') { foo << 2 }
+        @set.run_command(@ctx, 'foo')
+
+        foo.should == [1, 2]
+      end
+
+      it 'should be called after the original command, using listing name' do
+        foo = []
+        @set.command(/^foo1/, '', :listing => 'foo') { foo << 1 }
+        @set.after_command('foo') { foo << 2 }
+        @set.run_command(@ctx, /^foo1/)
+
+        foo.should == [1, 2]
+      end
+
+      it 'should share the context with the original command' do
+        @ctx[:target] = "test target string".__binding__
+        after_val   = nil
+        orig_val    = nil
+        @set.command('foo') { orig_val = target }
+        @set.after_command('foo') { after_val = target }
+        @set.run_command(@ctx, 'foo')
+
+        after_val.should == @ctx[:target]
+        orig_val.should == @ctx[:target]
+      end
+
+      it 'should determine the return value for the command' do
+        @set.command('foo', 'bar', :keep_retval => true) { 1 }
+        @set.after_command('foo') { 2 }
+        @set.run_command(@ctx, 'foo').should == 2
+      end
+
+      it 'should work when applied multiple times' do
+        foo = []
+        @set.command('foo') { foo << 1 }
+        @set.after_command('foo') { foo << 2 }
+        @set.after_command('foo') { foo << 3 }
+        @set.after_command('foo') { foo << 4 }
+        @set.run_command(@ctx, 'foo')
+
+        foo.should == [1, 2, 3, 4]
+      end
+    end
+
+    describe "before_command and after_command" do
+      it 'should work when combining both before_command and after_command' do
+        foo = []
+        @set.command('foo') { foo << 1 }
+        @set.after_command('foo') { foo << 2 }
+        @set.before_command('foo') { foo << 3 }
+        @set.run_command(@ctx, 'foo')
+
+        foo.should == [3, 1, 2]
+      end
+
+    end
+
+  end
+
+  describe 'find_command' do
+    it 'should find commands with the right string' do
+      cmd = @set.command('rincewind'){ }
+      @set.find_command('rincewind').should == cmd
+    end
+
+    it 'should not find commands with spaces before' do
+      cmd = @set.command('luggage'){ }
+      @set.find_command(' luggage').should == nil
+    end
+
+    it 'should find commands with arguments after' do
+      cmd = @set.command('vetinari'){ }
+      @set.find_command('vetinari --knock 3').should == cmd
+    end
+
+    it 'should find commands with names containing spaces' do
+      cmd = @set.command('nobby nobbs'){ }
+      @set.find_command('nobby nobbs --steal petty-cash').should == cmd
+    end
+
+    it 'should find command defined by regex' do
+      cmd = @set.command(/(capt|captain) vimes/i){ }
+      @set.find_command('Capt Vimes').should == cmd
+    end
+
+    it 'should find commands defined by regex with arguments' do
+      cmd = @set.command(/(cpl|corporal) Carrot/i){ }
+      @set.find_command('cpl carrot --write-home').should == cmd
+    end
+
+    it 'should not find commands by listing' do
+      cmd = @set.command(/werewol(f|ve)s?/, 'only once a month', :listing => "angua"){ }
+      @set.find_command('angua').should == nil
+    end
+
+    it 'should not find commands without command_prefix' do
+      Pry.config.command_prefix = '%'
+      cmd = @set.command('detritus'){ }
+      @set.find_command('detritus').should == nil
+      Pry.config.command_prefix = ''
+    end
+
+    it "should find commands that don't use the prefix" do
+      Pry.config.command_prefix = '%'
+      cmd = @set.command('colon', 'Sergeant Fred', :use_prefix => false){ }
+      @set.find_command('colon').should == cmd
+      Pry.config.command_prefix = ''
+    end
+  end
+
+  describe '.valid_command?' do
+    it 'should be true for commands that can be found' do
+      cmd = @set.command('archchancellor')
+      @set.valid_command?('archchancellor of_the?(:University)').should == true
+    end
+
+    it 'should be false for commands that can\'' do
+      @set.valid_command?('def monkey(ape)').should == false
+    end
+
+    it 'should not cause argument interpolation' do
+      cmd = @set.command('hello')
+      lambda {
+        @set.valid_command?('hello #{raise "futz"}')
+      }.should.not.raise
+    end
+  end
+
+  describe '.process_line' do
+
+    it 'should return Result.new(false) if there is no matching command' do
+     result = @set.process_line('1 + 42')
+     result.command?.should == false
+     result.void_command?.should == false
+     result.retval.should == nil
+    end
+
+    it 'should return Result.new(true, VOID) if the command is not keep_retval' do
+      @set.create_command('mrs-cake') do
+        def process; 42; end
+      end
+
+      result = @set.process_line('mrs-cake')
+      result.command?.should == true
+      result.void_command?.should == true
+      result.retval.should == Pry::Command::VOID_VALUE
+    end
+
+    it 'should return Result.new(true, retval) if the command is keep_retval' do
+      @set.create_command('magrat', 'the maiden', :keep_retval => true) do
+        def process; 42; end
+      end
+
+      result = @set.process_line('magrat')
+      result.command?.should == true
+      result.void_command?.should == false
+      result.retval.should == 42
+    end
+
+    it 'should pass through context' do
+      ctx = {
+        :eval_string => "bloomers",
+        :pry_instance => Object.new,
+        :output => StringIO.new,
+        :target => binding
+      }
+      @set.create_command('agnes') do
+        define_method(:process) do
+          eval_string.should == ctx[:eval_string]
+          output.should == ctx[:output]
+          target.should == ctx[:target]
+          _pry_.should == ctx[:pry_instance]
+        end
+      end
+
+      @set.process_line('agnes', ctx)
+    end
+
+    it 'should add command_set to context' do
+      set = @set
+      @set.create_command(/nann+y ogg+/) do
+        define_method(:process) do
+          command_set.should == set
+        end
+      end
+
+      @set.process_line('nannnnnny oggggg')
+    end
+  end
 end

data/test/test_completion.rb

@@ -16,7 +16,7 @@ describe Pry::InputCompleter do
   end
 
   # another jruby hack :((
-  if !jruby?
+  if !Pry::Helpers::BaseHelpers.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

data/test/test_default_commands.rb

@@ -7,8 +7,7 @@ describe "Pry::Commands" do
       redirect_pry_io(InputTester.new("help ls", "exit-all"), str_output) do
         pry
       end
-      str_output.string.each_line.count.should == 1
-      str_output.string.should =~ /ls --help/
+      str_output.string.should =~ /Usage: ls/
     end
 
     it 'should display help for a regex command with a "listing"' do

data/test/test_default_commands/test_context.rb

@@ -2,9 +2,9 @@ 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
+    it 'should break out of the repl loop of Pry instance and return nil' do
       redirect_pry_io(InputTester.new("exit-all"), StringIO.new) do
-        Pry.new.repl(0).should == 0
+        Pry.new.repl(0).should == nil
       end
     end
 
@@ -31,6 +31,21 @@ describe "Pry::DefaultCommands::Context" do
     end
   end
 
+  describe "whereami" do
+    it 'should work with methods that have been undefined' do
+      class Cor
+        def blimey!
+          Cor.send :undef_method, :blimey!
+          # using [.] so the regex doesn't match itself
+          mock_pry(binding, 'whereami').should =~ /self[.]blimey!/
+        end
+      end
+
+      Cor.new.blimey!
+      Object.remove_const(:Cor)
+    end
+  end
+
   describe "exit" do
     it 'should pop a binding with exit' do
       b = Pry.binding_for(:outer)
@@ -44,7 +59,7 @@ describe "Pry::DefaultCommands::Context" do
     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
+      Pry.start(0, :input => StringIO.new("exit")).should == nil
     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
@@ -126,8 +141,15 @@ 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
+    it "should not leave the REPL session when given 'cd ..'" do
+      b = Pry.binding_for(Object.new) 
+      input = InputTester.new "cd ..", "$obj = self", "exit-all" 
+      
+      redirect_pry_io(input, StringIO.new) do
+        b.pry
+      end
+
+      $obj.should == b.eval("self")
     end
 
     it 'should break out to outer-most session with cd /' do