pry 0.8.4pre1-java → 0.9.0pre1-java

data/test/test_pry.rb

@@ -135,13 +135,18 @@ describe Pry do
       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 +158,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 +224,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 +389,143 @@ 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 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 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
+
+#            binding.pry
+            str_output.string.should =~ /hello bing/
+            $obj = nil
           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 '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 +537,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 +545,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 +561,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 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 :test, Pry::Commands do
-              command "jump-to" do
-                output.puts "jump-to the music"
+                command "help" do
+                  output.puts "help to the music"
+                end
               end
 
-              command "help" do
-                output.puts "help to the music"
-              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
+          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"
-
-          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 '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 'when several prompts on the stack' do
+
+              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