pry 0.8.3 → 0.8.4pre1

data/test/test_commandset.rb

@@ -0,0 +1,184 @@
+require 'helper'
+
+describe Pry::CommandSet do
+  before do
+    @set = Pry::CommandSet.new(:some_name)
+  end
+
+  it 'should use the name specified at creation' do
+    @set.name.should == :some_name
+  end
+
+  it 'should call the block used for the command when it is called' do
+    run = false
+    @set.command 'foo' do
+      run = true
+    end
+
+    @set.run_command nil, 'foo'
+    run.should == true
+  end
+
+  it 'should pass arguments of the command to the block' do
+    @set.command 'foo' do |*args|
+      args.should == [1, 2, 3]
+    end
+
+    @set.run_command nil, 'foo', 1, 2, 3
+  end
+
+  it 'should use the first argument as self' do
+    @set.command 'foo' do
+      self.should == true
+    end
+
+    @set.run_command true, 'foo'
+  end
+
+  it 'should raise an error when calling an undefined comand' do
+    @set.command('foo') {}
+    lambda {
+      @set.run_command nil, 'bar'
+    }.should.raise(Pry::NoCommandError)
+  end
+
+  it 'should be able to remove its own commands' do
+    @set.command('foo') {}
+    @set.delete 'foo'
+
+    lambda {
+      @set.run_command nil, 'foo'
+    }.should.raise(Pry::NoCommandError)
+  end
+
+  it 'should be able to import some commands from other sets' do
+    run = false
+
+    other_set = Pry::CommandSet.new :foo do
+      command('foo') { run = true }
+      command('bar') {}
+    end
+
+    @set.import_from(other_set, 'foo')
+
+    @set.run_command nil, 'foo'
+    run.should == true
+
+    lambda {
+      @set.run_command nil, 'bar'
+    }.should.raise(Pry::NoCommandError)
+  end
+
+  it 'should be able to import a whole set' do
+    run = []
+
+    other_set = Pry::CommandSet.new :foo do
+      command('foo') { run << true }
+      command('bar') { run << true }
+    end
+
+    @set.import other_set
+
+    @set.run_command nil, 'foo'
+    @set.run_command nil, 'bar'
+    run.should == [true, true]
+  end
+
+  it 'should be able to import sets at creation' do
+    run = false
+    @set.command('foo') { run = true }
+
+    Pry::CommandSet.new(:other, @set).run_command nil, 'foo'
+    run.should == true
+  end
+
+  it 'should set the descriptions of commands' do
+    @set.command('foo', 'some stuff') {}
+    @set.commands['foo'].description.should == 'some stuff'
+  end
+
+  it 'should be able to alias method' do
+    run = false
+    @set.command('foo', 'stuff') { run = true }
+
+    @set.alias_command 'bar', 'foo'
+    @set.commands['bar'].name.should == 'bar'
+    @set.commands['bar'].description.should == 'stuff'
+
+    @set.run_command nil, 'bar'
+    run.should == true
+  end
+
+  it 'should be able to change the descritpions of methods' do
+    @set.command('foo', 'bar') {}
+    @set.desc 'foo', 'baz'
+
+    @set.commands['foo'].description.should == 'baz'
+  end
+
+  it 'should return nil for commands by default' do
+    @set.command('foo') { 3 }
+    @set.run_command(nil, 'foo').should == nil
+  end
+
+  it 'should be able to keep return values' do
+    @set.command('foo', '', :keep_retval => true) { 3 }
+    @set.run_command(nil, 'foo').should == 3
+  end
+
+  it 'should be able to have its own helpers' do
+    @set.command('foo') do
+      should.respond_to :my_helper
+    end
+
+    @set.helpers do
+      def my_helper; end
+    end
+
+    @set.run_command(Pry::CommandContext.new, 'foo')
+    Pry::CommandContext.new.should.not.respond_to :my_helper
+  end
+
+  it 'should not recreate a new heler module when helpers is called' do
+    @set.command('foo') do
+      should.respond_to :my_helper
+      should.respond_to :my_other_helper
+    end
+
+    @set.helpers do
+      def my_helper; end
+    end
+
+    @set.helpers do
+      def my_other_helper; end
+    end
+
+    @set.run_command(Pry::CommandContext.new, 'foo')
+  end
+
+  it 'should import helpers from imported sets' do
+    imported_set = Pry::CommandSet.new :test do
+      helpers do
+        def imported_helper_method; end
+      end
+    end
+
+    @set.import imported_set
+    @set.command('foo') { should.respond_to :imported_helper_method }
+    @set.run_command(Pry::CommandContext.new, 'foo')
+  end
+
+  it 'should import helpers even if only some commands are imported' do
+    imported_set = Pry::CommandSet.new :test do
+      helpers do
+        def imported_helper_method; end
+      end
+
+      command('bar') {}
+    end
+
+    @set.import_from imported_set, 'bar'
+    @set.command('foo') { should.respond_to :imported_helper_method }
+    @set.run_command(Pry::CommandContext.new, 'foo')
+  end
+end

data/test/{test.rb → test_pry.rb}

@@ -1,11 +1,4 @@
-direc = File.dirname(__FILE__)
-
-$LOAD_PATH.unshift "#{direc}/../lib"
-
-require 'rubygems'
-require 'bacon'
-require "pry"
-require "#{direc}/test_helper"
+require 'helper'
 
 puts "Ruby Version #{RUBY_VERSION}"
 puts "Testing Pry #{Pry::VERSION}"
@@ -24,6 +17,20 @@ describe Pry do
         Object.send(:remove_const, :Hello)
       end
 
+      # bug fix for https://github.com/banister/pry/issues/93
+      it 'should not leak pry constants into Object namespace' do
+        input_string = "CommandContext"
+        str_output = StringIO.new
+        o = Object.new
+        pry_tester = Pry.new(:input => StringIO.new(input_string),
+                             :output => str_output,
+                             :exception_handler => proc { |_, exception| @excep = exception },
+                             :print => proc {}
+                             ).rep(o)
+
+        @excep.is_a?(NameError).should == true
+      end
+
       it 'should set an ivar on an object' do
         input_string = "@x = 10"
         input = InputTester.new(input_string)
@@ -135,7 +142,7 @@ describe Pry do
 
         it "should run the rc file only once" do
           Pry.should_load_rc = true
-          Pry::RC_FILES << "#{direc}/testrc"
+          Pry::RC_FILES << File.expand_path("../testrc", __FILE__)
 
           Pry.start(self, :input => StringIO.new("exit\n"), :output => Pry::NullOutput)
           TEST_RC.should == [0]
@@ -379,56 +386,56 @@ describe Pry do
           str_output2.string.should =~ /7/
         end
 
-        describe "Pry.run_command" do
-          before do
-            class RCTest
-              def a() end
-              B = 20
-              @x = 10
-            end
-          end
-
-          after do
-            Object.remove_const(:RCTest)
-          end
-
-          it "should execute command in the appropriate object context" do
-            result = Pry.run_command "ls", :context => RCTest
-            result.map(&:to_sym).should == [:@x]
-          end
-
-          it "should execute command with parameters in the appropriate object context" do
-            result = Pry.run_command "ls -M", :context => RCTest
-            result.map(&:to_sym).should == [:a]
-          end
-
-          it "should execute command and show output with :show_output => true flag" do
-            str = StringIO.new
-            Pry.output = str
-            result = Pry.run_command "ls -afv", :context => RCTest, :show_output => true
-            str.string.should =~ /global variables/
-            Pry.output = $stdout
-          end
-
-          it "should execute command with multiple parameters" do
-            result = Pry.run_command "ls -c -M RCTest"
-            result.map(&:to_sym).should == [:a, :B]
-          end
-        end
+        # describe "Pry.run_command" do
+        #   before do
+        #     class RCTest
+        #       def a() end
+        #       B = 20
+        #       @x = 10
+        #     end
+        #   end
+
+        #   after do
+        #     Object.remove_const(:RCTest)
+        #   end
+
+        #   it "should execute command in the appropriate object context" do
+        #     result = Pry.run_command "ls", :context => RCTest
+        #     result.map(&:to_sym).should == [:@x]
+        #   end
+
+        #   it "should execute command with parameters in the appropriate object context" do
+        #     result = Pry.run_command "ls -M", :context => RCTest
+        #     result.map(&:to_sym).should == [:a]
+        #   end
+
+        #   it "should execute command and show output with :show_output => true flag" do
+        #     str = StringIO.new
+        #     Pry.output = str
+        #     result = Pry.run_command "ls -afv", :context => RCTest, :show_output => true
+        #     str.string.should =~ /global variables/
+        #     Pry.output = $stdout
+        #   end
+
+        #   it "should execute command with multiple parameters" do
+        #     result = Pry.run_command "ls -c -M RCTest"
+        #     result.map(&:to_sym).should == [:a, :B]
+        #   end
+        # end
 
         describe "commands" do
           it 'should interpolate ruby code into commands' do
-            klass = Class.new(Pry::CommandBase) do
+            klass = Pry::CommandSet.new :test do
               command "hello", "", :keep_retval => true do |arg|
                 arg
               end
             end
 
-            $test_interpolation = "bing"
+            @test_interpolation = "bing"
             str_output = StringIO.new
-            Pry.new(:input => StringIO.new("hello #{$test_interpolation}"), :output => str_output, :commands => klass).rep
+            Pry.new(:input => StringIO.new("hello #{@test_interpolation}"), :output => str_output, :commands => klass).rep
             str_output.string.should =~ /bing/
-            $test_interpolation = nil
+            @test_interpolation = nil
           end
 
           it 'should create a comand in  a nested context and that command should be accessible from the parent' do
@@ -442,47 +449,43 @@ describe Pry do
           end
 
           it 'should define a command that keeps its return value' do
-            class Command68 < Pry::CommandBase
+            klass = Pry::CommandSet.new :test do
               command "hello", "", :keep_retval => true do
                 :kept_hello
               end
             end
             str_output = StringIO.new
-            Pry.new(:input => StringIO.new("hello\n"), :output => str_output, :commands => Command68).rep
+            Pry.new(:input => StringIO.new("hello\n"), :output => str_output, :commands => klass).rep
             str_output.string.should =~ /:kept_hello/
             str_output.string.should =~ /=>/
-
-            Object.remove_const(:Command68)
           end
 
           it 'should define a command that does NOT keep its return value' do
-            class Command68 < Pry::CommandBase
+            klass = Pry::CommandSet.new :test do
               command "hello", "", :keep_retval => false do
                 :kept_hello
               end
             end
             str_output = StringIO.new
-            Pry.new(:input => StringIO.new("hello\n"), :output => str_output, :commands => Command68).rep
+            Pry.new(:input => StringIO.new("hello\n"), :output => str_output, :commands => klass).rep
             (str_output.string =~ /:kept_hello/).should == nil
             str_output.string !~ /=>/
-
-            Object.remove_const(:Command68)
           end
 
           it 'should set the commands default, and the default should be overridable' do
-            class Command0 < Pry::CommandBase
+            klass = Pry::CommandSet.new :test do
               command "hello" do
                 output.puts "hello world"
               end
             end
 
-            Pry.commands = Command0
+            Pry.commands = klass
 
             str_output = StringIO.new
             Pry.new(:input => InputTester.new("hello"), :output => str_output).rep
             str_output.string.should =~ /hello world/
 
-            class Command1 < Pry::CommandBase
+            other_klass = Pry::CommandSet.new :test2 do
               command "goodbye", "" do
                 output.puts "goodbye world"
               end
@@ -490,73 +493,55 @@ describe Pry do
 
             str_output = StringIO.new
 
-            Pry.new(:input => InputTester.new("goodbye"), :output => str_output, :commands => Command1).rep
+            Pry.new(:input => InputTester.new("goodbye"), :output => str_output, :commands => other_klass).rep
             str_output.string.should =~ /goodbye world/
-
-            Object.remove_const(:Command0)
-            Object.remove_const(:Command1)
           end
 
           it 'should inherit "help" command from Pry::CommandBase' do
-            class Command2 < Pry::CommandBase
+            klass = Pry::CommandSet.new :test do
               command "h", "h command" do
               end
             end
 
-            Command2.commands.keys.size.should == 3
-            Command2.commands.keys.include?("help").should == true
-            Command2.commands.keys.include?("install").should == true
-            Command2.commands.keys.include?("h").should == true
-
-            Object.remove_const(:Command2)
+            klass.commands.keys.size.should == 3
+            klass.commands.keys.include?("help").should == true
+            klass.commands.keys.include?("install").should == true
+            klass.commands.keys.include?("h").should == true
           end
 
           it 'should inherit commands from Pry::Commands' do
-            class Command3 < Pry::Commands
+            klass = Pry::CommandSet.new :test, Pry::Commands do
               command "v" do
               end
             end
 
-            Command3.commands.include?("nesting").should == true
-            Command3.commands.include?("jump-to").should == true
-            Command3.commands.include?("cd").should == true
-            Command3.commands.include?("v").should == true
-
-            Object.remove_const(:Command3)
+            klass.commands.include?("nesting").should == true
+            klass.commands.include?("jump-to").should == true
+            klass.commands.include?("cd").should == true
+            klass.commands.include?("v").should == true
           end
 
           it 'should alias a command with another command' do
-            class Command6 < Pry::CommandBase
+              klass = Pry::CommandSet.new :test do
               alias_command "help2", "help"
             end
 
-            Command6.commands["help2"].should == Command6.commands["help"]
-            # str_output = StringIO.new
-            # Pry.new(:input => InputTester.new("run_v"), :output => str_output, :commands => Command3).rep
-            # str_output.string.should =~ /v command/
 
-            Object.remove_const(:Command6)
+              klass.commands["help2"].block.should == klass.commands["help"].block
           end
 
           it 'should change description of a command using desc' do
-
-            class Command7 < Pry::Commands
-            end
-
-            orig = Command7.commands["help"][:description]
-
-            class Command7
+            klass = Pry::CommandSet.new :test do; end
+            orig = klass.commands["help"].description
+            klass.instance_eval do
               desc "help", "blah"
             end
-
-            Command7.commands["help"][:description].should.not == orig
-            Command7.commands["help"][:description].should == "blah"
-
-            Object.remove_const(:Command7)
+            klass.commands["help"].description.should.not == orig
+            klass.commands["help"].description.should == "blah"
           end
 
           it 'should run a command from within a command' do
-            class Command01 < Pry::Commands
+            klass = Pry::CommandSet.new :test do
               command "v" do
                 output.puts "v command"
               end
@@ -567,69 +552,56 @@ describe Pry do
             end
 
             str_output = StringIO.new
-            Pry.new(:input => InputTester.new("run_v"), :output => str_output, :commands => Command01).rep
+            Pry.new(:input => InputTester.new("run_v"), :output => str_output, :commands => klass).rep
             str_output.string.should =~ /v command/
-
-            Object.remove_const(:Command01)
           end
 
           it 'should enable an inherited method to access opts and output and target, due to instance_exec' do
-            class Command3 < Pry::Commands
+            klass = Pry::CommandSet.new :test do
               command "v" do
                 output.puts "#{target.eval('self')}"
               end
             end
 
-            class Command4 < Command3
+            child_klass = Pry::CommandSet.new :test2, klass do
             end
 
             str_output = StringIO.new
             Pry.new(:print => proc {}, :input => InputTester.new("v"),
-                    :output => str_output, :commands => Command4).rep("john")
+                    :output => str_output, :commands => child_klass).rep("john")
 
             str_output.string.rstrip.should == "john"
-
-            Object.remove_const(:Command3)
-            Object.remove_const(:Command4)
           end
 
           it 'should import commands from another command object' do
-            Object.remove_const(:Command77) if Object.const_defined?(:Command77)
-
-            class Command77 < Pry::CommandBase
-              import_from Pry::Commands, "status", "jump-to"
+            klass = Pry::CommandSet.new :test do
+              import_from Pry::Commands, "ls", "jump-to"
             end
 
-            str_output = StringIO.new
-            Pry.new(:print => proc {}, :input => InputTester.new("status"),
-                    :output => str_output, :commands => Command77).rep("john")
-            str_output.string.should =~ /Status:/
-
-            Object.remove_const(:Command77)
-          end
+              klass.commands.include?("ls").should == true
+              klass.commands.include?("jump-to").should == true
+            end
 
           it 'should delete some inherited commands when using delete method' do
-            class Command3 < Pry::Commands
+            klass = Pry::CommandSet.new :test, Pry::Commands do
               command "v" do
               end
 
-              delete "show_doc", "show_method"
+              delete "show-doc", "show-method"
               delete "ls"
             end
 
-            Command3.commands.include?("nesting").should == true
-            Command3.commands.include?("jump-to").should == true
-            Command3.commands.include?("cd").should == true
-            Command3.commands.include?("v").should == true
-            Command3.commands.include?("show_doc").should == false
-            Command3.commands.include?("show_method").should == false
-            Command3.commands.include?("ls").should == false
-
-            Object.remove_const(:Command3)
+            klass.commands.include?("nesting").should == true
+            klass.commands.include?("jump-to").should == true
+            klass.commands.include?("cd").should == true
+            klass.commands.include?("v").should == true
+            klass.commands.include?("show-doc").should == false
+            klass.commands.include?("show-method").should == false
+            klass.commands.include?("ls").should == false
           end
 
           it 'should override some inherited commands' do
-            class Command3 < Pry::Commands
+            klass = Pry::CommandSet.new :test, Pry::Commands do
               command "jump-to" do
                 output.puts "jump-to the music"
               end
@@ -643,14 +615,13 @@ describe Pry do
             Pry.print = proc {}
 
             str_output = StringIO.new
-            Pry.new(:input => InputTester.new("jump-to"), :output => str_output, :commands => Command3).rep
+            Pry.new(:input => InputTester.new("jump-to"), :output => str_output, :commands => klass).rep
             str_output.string.rstrip.should == "jump-to the music"
 
             str_output = StringIO.new
-            Pry.new(:input => InputTester.new("help"), :output => str_output, :commands => Command3).rep
+            Pry.new(:input => InputTester.new("help"), :output => str_output, :commands => klass).rep
             str_output.string.rstrip.should == "help to the music"
 
-            Object.remove_const(:Command3)
 
             Pry.reset_defaults
             Pry.color = false
@@ -737,6 +708,67 @@ describe Pry do
             Pry.new.select_prompt(true, 0).should == "test prompt> "
             Pry.new.select_prompt(false, 0).should == "test prompt* "
           end
+
+          describe 'storing and restoring the prompt' do
+            before do
+              make = lambda do |name,i|
+                prompt = [ proc { "#{i}>" } , proc { "#{i+1}>" } ]
+                (class << prompt; self; end).send(:define_method, :inspect) { "<Prompt-#{name}>" }
+                prompt
+              end
+              @a , @b , @c = make[:a,0] , make[:b,1] , make[:c,2]
+              @pry = Pry.new :prompt => @a
+            end
+            it 'should have a prompt stack' do
+              @pry.push_prompt @b
+              @pry.push_prompt @c
+              @pry.prompt.should == @c
+              @pry.pop_prompt
+              @pry.prompt.should == @b
+              @pry.pop_prompt
+              @pry.prompt.should == @a
+            end
+
+            it 'should restore overridden prompts when returning from file-mode' do
+              pry = Pry.new :input => InputTester.new('shell-mode', 'shell-mode'),
+                            :prompt => [ proc { 'P>' } ] * 2
+              pry.select_prompt(true, 0).should == "P>"
+              pry.re
+              pry.select_prompt(true, 0).should =~ /\Apry .* \$ \z/
+              pry.re
+              pry.select_prompt(true, 0).should == "P>"
+            end
+
+            it '#pop_prompt should return the popped prompt' do
+              @pry.push_prompt @b
+              @pry.push_prompt @c
+              @pry.pop_prompt.should == @c
+              @pry.pop_prompt.should == @b
+            end
+
+            it 'should not pop the last prompt' do
+              @pry.push_prompt @b
+              @pry.pop_prompt.should == @b
+              @pry.pop_prompt.should == @a
+              @pry.pop_prompt.should == @a
+              @pry.prompt.should == @a
+            end
+
+            describe '#prompt= should replace the current prompt with the new prompt' do
+              it 'when only one prompt on the stack' do
+                @pry.prompt = @b
+                @pry.prompt.should == @b
+                @pry.pop_prompt.should == @b
+                @pry.pop_prompt.should == @b
+              end
+              it 'when several prompts on the stack' do
+                @pry.push_prompt @b
+                @pry.prompt = @c
+                @pry.pop_prompt.should == @c
+                @pry.pop_prompt.should == @a
+              end
+            end
+          end
         end
 
         it 'should set the hooks default, and the default should be overridable' do