pry 0.8.4pre1-i386-mingw32 → 0.9.0-i386-mingw32

data/test/test_history_array.rb

@@ -0,0 +1,65 @@
+require 'helper'
+
+describe Pry::HistoryArray do
+  before do
+    @array = Pry::HistoryArray.new 10
+  end
+
+  it 'should have a maximum size specifed at creation time' do
+    @array.max_size.should == 10
+  end
+
+  it 'should be able to be added objects to' do
+    @array << 1 << 2 << 3
+    @array.size.should == 3
+    @array.to_a.should == [1, 2, 3]
+  end
+
+  it 'should be able to access single elements' do
+    @array << 1 << 2 << 3
+    @array[2].should == 3
+  end
+
+  it 'should be able to access negative indices' do
+    @array << 1 << 2 << 3
+    @array[-1].should == 3
+  end
+
+  it 'should be able to access ranges' do
+    @array << 1 << 2 << 3 << 4
+    @array[1..2].should == [2, 3]
+  end
+
+  it 'should be able to access ranges starting from a negative index' do
+    @array << 1 << 2 << 3 << 4
+    @array[-2..3].should == [3, 4]
+  end
+
+  it 'should be able to access ranges ending at a negative index' do
+    @array << 1 << 2 << 3 << 4
+    @array[2..-1].should == [3, 4]
+  end
+
+  it 'should be able to access ranges using only negative indices' do
+    @array << 1 << 2 << 3 << 4
+    @array[-2..-1].should == [3, 4]
+  end
+
+  it 'should be able to use range where end is excluded' do
+    @array << 1 << 2 << 3 << 4
+    @array[-2...-1].should == [3]
+  end
+
+  it 'should be able to access slices using a size' do
+    @array << 1 << 2 << 3 << 4
+    @array[-3, 2].should == [2, 3]
+  end
+
+  it 'should remove older entries' do
+    11.times { |n| @array << n }
+
+    @array[0].should  == nil
+    @array[1].should  == 1
+    @array[10].should == 10
+  end
+end

data/test/test_pry.rb

@@ -6,6 +6,15 @@ puts "With method_source version #{MethodSource::VERSION}"
 puts "--"
 
 describe Pry do
+
+  describe 'warning emissions' do
+    it 'should emit no warnings' do
+      Open4.popen4 'ruby -I lib -rubygems -r"pry" -W -e "exit"' do |pid, stdin, stdout, stderr|
+        stderr.read.empty?.should == true
+      end
+    end
+  end
+
   describe "open a Pry session on an object" do
     describe "rep" do
       before do
@@ -31,6 +40,17 @@ describe Pry do
         @excep.is_a?(NameError).should == true
       end
 
+      if defined?(BasicObject)
+        it 'should be able to operate inside the BasicObject class' do
+          $obj = nil
+          redirect_pry_io(InputTester.new(":foo", "$obj = _", "exit-all"), StringIO.new) do
+            BasicObject.pry
+          end
+          $obj.should == :foo
+          $obj = nil
+        end
+      end
+
       it 'should set an ivar on an object' do
         input_string = "@x = 10"
         input = InputTester.new(input_string)
@@ -134,14 +154,80 @@ describe Pry do
         end
       end
 
+      describe "history arrays" do
+        it 'sets _ to the last result' do
+          res   = []
+          input = InputTester.new *[":foo", "self << _", "42", "self << _"]
+          pry   = Pry.new(:input => input, :output => Pry::NullOutput)
+          pry.repl(res)
+
+          res.should == [:foo, 42]
+        end
+
+        it 'sets out to an array with the result' do
+          res   = {}
+          input = InputTester.new *[":foo", "42", "self[:res] = out"]
+          pry   = Pry.new(:input => input, :output => Pry::NullOutput)
+          pry.repl(res)
+
+          res[:res].should.be.kind_of Pry::HistoryArray
+          res[:res][1..2].should == [:foo, 42]
+        end
+
+        it 'sets inp to an array with the entered lines' do
+          res   = {}
+          input = InputTester.new *[":foo", "42", "self[:res] = inp"]
+          pry   = Pry.new(:input => input, :output => Pry::NullOutput)
+          pry.repl(res)
+
+          res[:res].should.be.kind_of Pry::HistoryArray
+          res[:res][1..2].should == [":foo\n", "42\n"]
+        end
+
+        it 'uses 100 as the size of inp and out' do
+          res   = []
+          input = InputTester.new *["self << out.max_size << inp.max_size"]
+          pry   = Pry.new(:input => input, :output => Pry::NullOutput)
+          pry.repl(res)
+
+          res.should == [100, 100]
+        end
+
+        it 'can change the size of the history arrays' do
+          res   = []
+          input = InputTester.new *["self << out.max_size << inp.max_size"]
+          pry   = Pry.new(:input => input, :output => Pry::NullOutput,
+                          :memory_size => 1000)
+          pry.repl(res)
+
+          res.should == [1000, 1000]
+        end
+
+        it 'store exceptions' do
+          res   = []
+          input = InputTester.new *["foo!","self << inp[-1] << out[-1]"]
+          pry   = Pry.new(:input => input, :output => Pry::NullOutput,
+                          :memory_size => 1000)
+          pry.repl(res)
+
+          res.first.should == "foo!\n"
+          res.last.should.be.kind_of NoMethodError
+        end
+      end
+
       describe "test loading rc files" do
+
+        before do
+          Pry.instance_variable_set(:@initial_session, true)
+        end
+
         after do
           Pry::RC_FILES.clear
-          Pry.should_load_rc = false
+          Pry.config.should_load_rc = false
         end
 
         it "should run the rc file only once" do
-          Pry.should_load_rc = true
+          Pry.config.should_load_rc = true
           Pry::RC_FILES << File.expand_path("../testrc", __FILE__)
 
           Pry.start(self, :input => StringIO.new("exit\n"), :output => Pry::NullOutput)
@@ -153,17 +239,17 @@ describe Pry do
           Object.remove_const(:TEST_RC)
         end
 
-        it "should not run the rc file at all if Pry.should_load_rc is false" do
-          Pry.should_load_rc = false
+        it "should not run the rc file at all if Pry.config.should_load_rc is false" do
+          Pry.config.should_load_rc = false
           Pry.start(self, :input => StringIO.new("exit\n"), :output => Pry::NullOutput)
           Object.const_defined?(:TEST_RC).should == false
         end
 
         it "should not load the rc file if #repl method invoked" do
-          Pry.should_load_rc = true
+          Pry.config.should_load_rc = true
           Pry.new(:input => StringIO.new("exit\n"), :output => Pry::NullOutput).repl(self)
           Object.const_defined?(:TEST_RC).should == false
-          Pry.should_load_rc = false
+          Pry.config.should_load_rc = false
         end
       end
 
@@ -219,10 +305,8 @@ describe Pry do
             val.class.instance_methods(false).map(&:to_sym).include?(:hello).should == true
           end
         end
-
       end
 
-
       describe "commands" do
         it 'should run a command with no parameter' do
           pry_tester = Pry.new
@@ -386,70 +470,180 @@ 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 "commands" do
           it 'should interpolate ruby code into commands' do
-            klass = Pry::CommandSet.new :test do
+            klass = Pry::CommandSet.new 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 NOT interpolate ruby code into commands if :interpolate => false' do
+            klass = Pry::CommandSet.new do
+              command "hello", "", :keep_retval => true, :interpolate => false do |arg|
+                arg
+              end
+            end
+
+            $test_interpolation = "bing"
+            str_output = StringIO.new
+            Pry.new(:input => StringIO.new('hello #{$test_interpolation}'), :output => str_output, :commands => klass).rep
+            str_output.string.should =~ /test_interpolation/
+            $test_interpolation = nil
+          end
+
+          it 'should NOT try to interpolate pure ruby code (no commands) ' do
+            str_output = StringIO.new
+            Pry.new(:input => StringIO.new('puts \'#{aggy}\''), :output => str_output).rep
+            str_output.string.should.not =~ /NameError/
+
+            Pry.new(:input => StringIO.new('puts #{aggy}'), :output => str_output).rep
+            str_output.string.should.not =~ /NameError/
+
+            $test_interpolation = "blah"
+            Pry.new(:input => StringIO.new('puts \'#{$test_interpolation}\''), :output => str_output).rep
+
+            str_output.string.should.not =~ /blah/
+            $test_interpolation = nil
+          end
+
+          it 'should create a command with a space in its name' do
+            set = Pry::CommandSet.new do
+              command "hello baby", "" do
+                output.puts "hello baby command"
+              end
+            end
+
+            str_output = StringIO.new
+            redirect_pry_io(InputTester.new("hello baby", "exit-all"), str_output) do
+              Pry.new(:commands => set).rep
+            end
+
+            str_output.string.should =~ /hello baby command/
+          end
+
+          it 'should create a command with a space in its name and pass an argument' do
+            set = Pry::CommandSet.new do
+              command "hello baby", "" do |arg|
+                output.puts "hello baby command #{arg}"
+              end
+            end
+
+            str_output = StringIO.new
+            redirect_pry_io(InputTester.new("hello baby john"), str_output) do
+              Pry.new(:commands => set).rep
+            end
+
+            str_output.string.should =~ /hello baby command john/
+          end
+
+          it 'should create a regex command and be able to invoke it' do
+            set = Pry::CommandSet.new do
+              command /hello(.)/, "" do
+                c = captures.first
+                output.puts "hello#{c}"
+              end
+            end
+
+            str_output = StringIO.new
+            redirect_pry_io(InputTester.new("hello1"), str_output) do
+              Pry.new(:commands => set).rep
+            end
+
+            str_output.string.should =~ /hello1/
+          end
+
+          it 'should create a regex command and pass captures into the args list before regular arguments' do
+            set = Pry::CommandSet.new do
+              command /hello(.)/, "" do |c1, a1|
+                output.puts "hello #{c1} #{a1}"
+              end
+            end
+
+            str_output = StringIO.new
+            redirect_pry_io(InputTester.new("hello1 baby"), str_output) do
+              Pry.new(:commands => set).rep
+            end
+
+            str_output.string.should =~ /hello 1 baby/
           end
 
-          it 'should create a comand in  a nested context and that command should be accessible from the parent' do
-            str_input = StringIO.new("@x=nil\ncd 7\n_pry_.commands.instance_eval {\ncommand('bing') { |arg| run arg }\n}\ncd ..\nbing ls\nexit")
+          it 'should create a regex command and interpolate the captures' do
+            set = Pry::CommandSet.new do
+              command /hello (.*)/, "" do |c1|
+                output.puts "hello #{c1}"
+              end
+            end
+
+            str_output = StringIO.new
+            $obj = "bing"
+            redirect_pry_io(InputTester.new('hello #{$obj}'), str_output) do
+              Pry.new(:commands => set).rep
+            end
+
+            str_output.string.should =~ /hello bing/
+            $obj = nil
+          end
+
+          it 'should create a regex command and arg_string should be interpolated' do
+            set = Pry::CommandSet.new do
+              command /hello(\w+)/, "" do |c1, a1, a2, a3|
+                output.puts "hello #{c1} #{a1} #{a2} #{a3}"
+              end
+            end
+
+            str_output = StringIO.new
+            $a1 = "bing"
+            $a2 = "bong"
+            $a3 = "bang"
+            redirect_pry_io(InputTester.new('hellojohn #{$a1} #{$a2} #{$a3}'), str_output) do
+              Pry.new(:commands => set).rep
+            end
+
+            str_output.string.should =~ /hello john bing bong bang/
+
+            $a1 = nil
+            $a2 = nil
+            $a3 = nil
+          end
+
+
+          it 'if a regex capture is missing it should be nil' do
+            set = Pry::CommandSet.new do
+              command /hello(.)?/, "" do |c1, a1|
+                output.puts "hello #{c1.inspect} #{a1}"
+              end
+            end
+
             str_output = StringIO.new
-            Pry.input = str_input
-            obj = Object.new
-            Pry.new(:output => str_output).repl(obj)
-            Pry.input = Readline
-            str_output.string.should =~ /@x/
+            redirect_pry_io(InputTester.new("hello baby"), str_output) do
+              Pry.new(:commands => set).rep
+            end
+
+            str_output.string.should =~ /hello nil baby/
+          end
+
+          it 'should create a command in  a nested context and that command should be accessible from the parent' do
+            redirect_pry_io(StringIO.new, StringIO.new) do
+              str_input = StringIO.new("@x=nil\ncd 7\n_pry_.commands.instance_eval {\ncommand('bing') { |arg| run arg }\n}\ncd ..\nbing ls\nexit")
+              str_output = StringIO.new
+              Pry.input = str_input
+              obj = Object.new
+              Pry.new(:output => str_output).repl(obj)
+              Pry.input = Readline
+              str_output.string.should =~ /@x/
+            end
           end
 
           it 'should define a command that keeps its return value' do
-            klass = Pry::CommandSet.new :test do
+            klass = Pry::CommandSet.new do
               command "hello", "", :keep_retval => true do
                 :kept_hello
               end
@@ -461,7 +655,7 @@ describe Pry do
           end
 
           it 'should define a command that does NOT keep its return value' do
-            klass = Pry::CommandSet.new :test do
+            klass = Pry::CommandSet.new do
               command "hello", "", :keep_retval => false do
                 :kept_hello
               end
@@ -469,11 +663,11 @@ describe Pry do
             str_output = StringIO.new
             Pry.new(:input => StringIO.new("hello\n"), :output => str_output, :commands => klass).rep
             (str_output.string =~ /:kept_hello/).should == nil
-            str_output.string !~ /=>/
+              str_output.string !~ /=>/
           end
 
           it 'should set the commands default, and the default should be overridable' do
-            klass = Pry::CommandSet.new :test do
+            klass = Pry::CommandSet.new do
               command "hello" do
                 output.puts "hello world"
               end
@@ -485,342 +679,383 @@ describe Pry do
             Pry.new(:input => InputTester.new("hello"), :output => str_output).rep
             str_output.string.should =~ /hello world/
 
-            other_klass = Pry::CommandSet.new :test2 do
-              command "goodbye", "" do
-                output.puts "goodbye world"
+                other_klass = Pry::CommandSet.new do
+                command "goodbye", "" do
+                  output.puts "goodbye world"
+                end
               end
-            end
 
-            str_output = StringIO.new
+              str_output = StringIO.new
 
-            Pry.new(:input => InputTester.new("goodbye"), :output => str_output, :commands => other_klass).rep
-            str_output.string.should =~ /goodbye world/
-          end
+              Pry.new(:input => InputTester.new("goodbye"), :output => str_output, :commands => other_klass).rep
+              str_output.string.should =~ /goodbye world/
+            end
 
-          it 'should inherit "help" command from Pry::CommandBase' do
-            klass = Pry::CommandSet.new :test do
-              command "h", "h command" do
+            it 'should inherit "help" command from Pry::CommandBase' do
+              klass = Pry::CommandSet.new do
+                command "h", "h command" do
+                end
               end
-            end
 
-            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
+              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
-            klass = Pry::CommandSet.new :test, Pry::Commands do
-              command "v" do
+            it 'should inherit commands from Pry::Commands' do
+              klass = Pry::CommandSet.new Pry::Commands do
+                command "v" do
+                end
               end
+
+              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
 
-            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
+              klass = Pry::CommandSet.new do
+                alias_command "help2", "help"
+              end
+              klass.commands["help2"].block.should == klass.commands["help"].block
+            end
 
-          it 'should alias a command with another command' do
-              klass = Pry::CommandSet.new :test do
-              alias_command "help2", "help"
+            it 'should change description of a command using desc' do
+              klass = Pry::CommandSet.new do; end
+              orig = klass.commands["help"].description
+              klass.instance_eval do
+                desc "help", "blah"
+              end
+              klass.commands["help"].description.should.not == orig
+              klass.commands["help"].description.should == "blah"
             end
 
+            it 'should run a command from within a command' do
+              klass = Pry::CommandSet.new do
+                command "v" do
+                  output.puts "v command"
+                end
 
-              klass.commands["help2"].block.should == klass.commands["help"].block
-          end
+                command "run_v" do
+                  run "v"
+                end
+              end
 
-          it 'should change description of a command using desc' do
-            klass = Pry::CommandSet.new :test do; end
-            orig = klass.commands["help"].description
-            klass.instance_eval do
-              desc "help", "blah"
+              str_output = StringIO.new
+              Pry.new(:input => InputTester.new("run_v"), :output => str_output, :commands => klass).rep
+              str_output.string.should =~ /v command/
             end
-            klass.commands["help"].description.should.not == orig
-            klass.commands["help"].description.should == "blah"
-          end
 
-          it 'should run a command from within a command' do
-            klass = Pry::CommandSet.new :test do
-              command "v" do
-                output.puts "v command"
+            it 'should run a regex command from within a command' do
+              klass = Pry::CommandSet.new do
+                command /v(.*)?/ do |arg|
+                  output.puts "v #{arg}"
+                end
+
+                command "run_v" do
+                  run "vbaby"
+                end
               end
 
-              command "run_v" do
-                run "v"
+              str_output = StringIO.new
+              redirect_pry_io(InputTester.new("run_v"), str_output) do
+                Pry.new(:commands => klass).rep
               end
+
+              str_output.string.should =~ /v baby/
             end
 
-            str_output = StringIO.new
-            Pry.new(:input => InputTester.new("run_v"), :output => str_output, :commands => klass).rep
-            str_output.string.should =~ /v command/
-          end
+            it 'should run a command from within a command with arguments' do
+              klass = Pry::CommandSet.new do
+                command /v(\w+)/ do |arg1, arg2|
+                  output.puts "v #{arg1} #{arg2}"
+                end
 
-          it 'should enable an inherited method to access opts and output and target, due to instance_exec' do
-            klass = Pry::CommandSet.new :test do
-              command "v" do
-                output.puts "#{target.eval('self')}"
+                command "run_v_explicit_parameter" do
+                  run "vbaby", "param"
+                end
+
+                command "run_v_embedded_parameter" do
+                  run "vbaby param"
+                end
               end
-            end
 
-            child_klass = Pry::CommandSet.new :test2, klass do
+              ["run_v_explicit_parameter", "run_v_embedded_parameter"].each do |cmd|
+                str_output = StringIO.new
+                redirect_pry_io(InputTester.new(cmd), str_output) do
+                  Pry.new(:commands => klass).rep
+                end
+                str_output.string.should =~ /v baby param/
+              end
             end
 
-            str_output = StringIO.new
-            Pry.new(:print => proc {}, :input => InputTester.new("v"),
-                    :output => str_output, :commands => child_klass).rep("john")
+            it 'should enable an inherited method to access opts and output and target, due to instance_exec' do
+              klass = Pry::CommandSet.new do
+                command "v" do
+                  output.puts "#{target.eval('self')}"
+                end
+              end
 
-            str_output.string.rstrip.should == "john"
-          end
+              child_klass = Pry::CommandSet.new klass do
+              end
+
+              str_output = StringIO.new
+              Pry.new(:print => proc {}, :input => InputTester.new("v"),
+                      :output => str_output, :commands => child_klass).rep("john")
 
-          it 'should import commands from another command object' do
-            klass = Pry::CommandSet.new :test do
-              import_from Pry::Commands, "ls", "jump-to"
+              str_output.string.rstrip.should == "john"
             end
 
+            it 'should import commands from another command object' do
+              klass = Pry::CommandSet.new do
+                import_from Pry::Commands, "ls", "jump-to"
+              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
-            klass = Pry::CommandSet.new :test, Pry::Commands do
-              command "v" do
+            it 'should delete some inherited commands when using delete method' do
+              klass = Pry::CommandSet.new Pry::Commands do
+                command "v" do
+                end
+
+                delete "show-doc", "show-method"
+                delete "ls"
               end
 
-              delete "show-doc", "show-method"
-              delete "ls"
+              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
 
-            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
-            klass = Pry::CommandSet.new :test, Pry::Commands do
-              command "jump-to" do
-                output.puts "jump-to the music"
-              end
+            it 'should override some inherited commands' do
+              klass = Pry::CommandSet.new Pry::Commands do
+                command "jump-to" do
+                  output.puts "jump-to the music"
+                end
 
-              command "help" do
-                output.puts "help to the music"
+                command "help" do
+                  output.puts "help to the music"
+                end
               end
-            end
 
-            # suppress evaluation output
-            Pry.print = proc {}
+              # suppress evaluation output
+              Pry.print = proc {}
 
-            str_output = StringIO.new
-            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("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 => klass).rep
-            str_output.string.rstrip.should == "help to the music"
+              str_output = StringIO.new
+              Pry.new(:input => InputTester.new("help"), :output => str_output, :commands => klass).rep
+              str_output.string.rstrip.should == "help to the music"
 
 
-            Pry.reset_defaults
-            Pry.color = false
+              Pry.reset_defaults
+              Pry.color = false
+            end
           end
-        end
-
-        it "should set the print default, and the default should be overridable" do
-          new_print = proc { |out, value| out.puts value }
-          Pry.print =  new_print
 
-          Pry.new.print.should == Pry.print
-          str_output = StringIO.new
-          Pry.new(:input => InputTester.new("\"test\""), :output => str_output).rep
-          str_output.string.should == "test\n"
+          it "should set the print default, and the default should be overridable" do
+            new_print = proc { |out, value| out.puts value }
+            Pry.print =  new_print
 
-          str_output = StringIO.new
-          Pry.new(:input => InputTester.new("\"test\""), :output => str_output,
-                  :print => proc { |out, value| out.puts value.reverse }).rep
-          str_output.string.should == "tset\n"
+            Pry.new.print.should == Pry.print
+            str_output = StringIO.new
+            Pry.new(:input => InputTester.new("\"test\""), :output => str_output).rep
+            str_output.string.should == "test\n"
 
-          Pry.new.print.should == Pry.print
-          str_output = StringIO.new
-          Pry.new(:input => InputTester.new("\"test\""), :output => str_output).rep
-          str_output.string.should == "test\n"
-        end
+            str_output = StringIO.new
+            Pry.new(:input => InputTester.new("\"test\""), :output => str_output,
+                    :print => proc { |out, value| out.puts value.reverse }).rep
+            str_output.string.should == "tset\n"
 
-        describe "pry return values" do
-          it 'should return the target object' do
-            Pry.start(self, :input => StringIO.new("exit"), :output => Pry::NullOutput).should == self
+            Pry.new.print.should == Pry.print
+            str_output = StringIO.new
+            Pry.new(:input => InputTester.new("\"test\""), :output => str_output).rep
+            str_output.string.should == "test\n"
           end
 
-          it 'should return the parameter given to exit' do
-            Pry.start(self, :input => StringIO.new("exit 10"), :output => Pry::NullOutput).should == 10
-          end
+          describe "pry return values" do
+            it 'should return the target object' do
+              Pry.start(self, :input => StringIO.new("exit"), :output => Pry::NullOutput).should == self
+            end
 
-          it 'should return the parameter (multi word string) given to exit' do
-            Pry.start(self, :input => StringIO.new("exit \"john mair\""), :output => Pry::NullOutput).should == "john mair"
-          end
+            it 'should return the parameter given to exit' do
+              Pry.start(self, :input => StringIO.new("exit 10"), :output => Pry::NullOutput).should == 10
+            end
 
-          it 'should return the parameter (function call) given to exit' do
-            Pry.start(self, :input => StringIO.new("exit 'abc'.reverse"), :output => Pry::NullOutput).should == 'cba'
-          end
+            it 'should return the parameter (multi word string) given to exit' do
+              Pry.start(self, :input => StringIO.new("exit \"john mair\""), :output => Pry::NullOutput).should == "john mair"
+            end
 
-          it 'should return the parameter (self) given to exit' do
-            Pry.start("carl", :input => StringIO.new("exit self"), :output => Pry::NullOutput).should == "carl"
+            it 'should return the parameter (function call) given to exit' do
+              Pry.start(self, :input => StringIO.new("exit 'abc'.reverse"), :output => Pry::NullOutput).should == 'cba'
+            end
+
+            it 'should return the parameter (self) given to exit' do
+              Pry.start("carl", :input => StringIO.new("exit self"), :output => Pry::NullOutput).should == "carl"
+            end
           end
-        end
 
-        describe "prompts" do
-          it 'should set the prompt default, and the default should be overridable (single prompt)' do
-            new_prompt = proc { "test prompt> " }
-            Pry.prompt =  new_prompt
+          describe "prompts" do
+            it 'should set the prompt default, and the default should be overridable (single prompt)' do
+              new_prompt = proc { "test prompt> " }
+              Pry.prompt =  new_prompt
 
-            Pry.new.prompt.should == Pry.prompt
-            Pry.new.select_prompt(true, 0).should == "test prompt> "
-            Pry.new.select_prompt(false, 0).should == "test prompt> "
+              Pry.new.prompt.should == Pry.prompt
+              Pry.new.select_prompt(true, 0).should == "test prompt> "
+              Pry.new.select_prompt(false, 0).should == "test prompt> "
 
-            new_prompt = proc { "A" }
-            pry_tester = Pry.new(:prompt => new_prompt)
-            pry_tester.prompt.should == new_prompt
-            pry_tester.select_prompt(true, 0).should == "A"
-            pry_tester.select_prompt(false, 0).should == "A"
+              new_prompt = proc { "A" }
+              pry_tester = Pry.new(:prompt => new_prompt)
+              pry_tester.prompt.should == new_prompt
+              pry_tester.select_prompt(true, 0).should == "A"
+              pry_tester.select_prompt(false, 0).should == "A"
 
-            Pry.new.prompt.should == Pry.prompt
-            Pry.new.select_prompt(true, 0).should == "test prompt> "
-            Pry.new.select_prompt(false, 0).should == "test prompt> "
-          end
+              Pry.new.prompt.should == Pry.prompt
+              Pry.new.select_prompt(true, 0).should == "test prompt> "
+              Pry.new.select_prompt(false, 0).should == "test prompt> "
+            end
 
-          it 'should set the prompt default, and the default should be overridable (multi prompt)' do
-            new_prompt = [proc { "test prompt> " }, proc { "test prompt* " }]
-            Pry.prompt =  new_prompt
+            it 'should set the prompt default, and the default should be overridable (multi prompt)' do
+              new_prompt = [proc { "test prompt> " }, proc { "test prompt* " }]
+              Pry.prompt =  new_prompt
 
-            Pry.new.prompt.should == Pry.prompt
-            Pry.new.select_prompt(true, 0).should == "test prompt> "
-            Pry.new.select_prompt(false, 0).should == "test prompt* "
+              Pry.new.prompt.should == Pry.prompt
+              Pry.new.select_prompt(true, 0).should == "test prompt> "
+              Pry.new.select_prompt(false, 0).should == "test prompt* "
 
-            new_prompt = [proc { "A" }, proc { "B" }]
-            pry_tester = Pry.new(:prompt => new_prompt)
-            pry_tester.prompt.should == new_prompt
-            pry_tester.select_prompt(true, 0).should == "A"
-            pry_tester.select_prompt(false, 0).should == "B"
+              new_prompt = [proc { "A" }, proc { "B" }]
+              pry_tester = Pry.new(:prompt => new_prompt)
+              pry_tester.prompt.should == new_prompt
+              pry_tester.select_prompt(true, 0).should == "A"
+              pry_tester.select_prompt(false, 0).should == "B"
 
-            Pry.new.prompt.should == Pry.prompt
-            Pry.new.select_prompt(true, 0).should == "test prompt> "
-            Pry.new.select_prompt(false, 0).should == "test prompt* "
-          end
+              Pry.new.prompt.should == Pry.prompt
+              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
+            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.should == @b
-                @pry.pop_prompt.should == @b
+                @pry.pop_prompt
+                @pry.prompt.should == @a
               end
-              it 'when several prompts on the stack' do
+
+              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.prompt = @c
+                @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
-        end
 
-        it 'should set the hooks default, and the default should be overridable' do
-          Pry.input = InputTester.new("exit")
-          Pry.hooks = {
-            :before_session => proc { |out,_| out.puts "HELLO" },
-            :after_session => proc { |out,_| out.puts "BYE" }
-          }
+          it 'should set the hooks default, and the default should be overridable' do
+            Pry.input = InputTester.new("exit")
+            Pry.hooks = {
+              :before_session => proc { |out,_| out.puts "HELLO" },
+              :after_session => proc { |out,_| out.puts "BYE" }
+            }
 
-          str_output = StringIO.new
-          Pry.new(:output => str_output).repl
-          str_output.string.should =~ /HELLO/
-          str_output.string.should =~ /BYE/
+            str_output = StringIO.new
+            Pry.new(:output => str_output).repl
+            str_output.string.should =~ /HELLO/
+            str_output.string.should =~ /BYE/
 
-          Pry.input.rewind
+            Pry.input.rewind
 
-          str_output = StringIO.new
-          Pry.new(:output => str_output,
-                  :hooks => {
-                    :before_session => proc { |out,_| out.puts "MORNING" },
-                    :after_session => proc { |out,_| out.puts "EVENING" }
-                  }
-                  ).repl
-
-          str_output.string.should =~ /MORNING/
-          str_output.string.should =~ /EVENING/
-
-          # try below with just defining one hook
-          Pry.input.rewind
-          str_output = StringIO.new
-          Pry.new(:output => str_output,
-                  :hooks => {
-                    :before_session => proc { |out,_| out.puts "OPEN" }
-                  }
-                  ).repl
+            str_output = StringIO.new
+            Pry.new(:output => str_output,
+                    :hooks => {
+                      :before_session => proc { |out,_| out.puts "MORNING" },
+                      :after_session => proc { |out,_| out.puts "EVENING" }
+                    }
+                    ).repl
+
+            str_output.string.should =~ /MORNING/
+            str_output.string.should =~ /EVENING/
+
+            # try below with just defining one hook
+            Pry.input.rewind
+            str_output = StringIO.new
+            Pry.new(:output => str_output,
+                    :hooks => {
+                      :before_session => proc { |out,_| out.puts "OPEN" }
+                    }
+                    ).repl
 
-          str_output.string.should =~ /OPEN/
+            str_output.string.should =~ /OPEN/
 
-          Pry.input.rewind
-          str_output = StringIO.new
-          Pry.new(:output => str_output,
-                  :hooks => {
-                    :after_session => proc { |out,_| out.puts "CLOSE" }
-                  }
-                  ).repl
+            Pry.input.rewind
+            str_output = StringIO.new
+            Pry.new(:output => str_output,
+                    :hooks => {
+                      :after_session => proc { |out,_| out.puts "CLOSE" }
+                    }
+                    ).repl
 
-          str_output.string.should =~ /CLOSE/
+            str_output.string.should =~ /CLOSE/
 
-          Pry.reset_defaults
-          Pry.color = false
+            Pry.reset_defaults
+            Pry.color = false
+          end
         end
       end
     end
   end
-end