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

data/test/test_default_commands/test_ls.rb

@@ -1,38 +1,5 @@
 require 'helper'
 describe "ls" do
-  describe "class_name" do
-    extend Pry::DefaultCommands::Ls.helper_module
-    it "should use the name of the class if it exists" do
-      class_name(Object).should == "Object"
-    end
-
-    it "should use the name of the module if it exists" do
-      class_name(Kernel).should == "Kernel"
-    end
-
-    it "should use Foo.self for singleton classes of classes" do
-      class_name(class << Object; self; end).should == "Object.self"
-    end
-
-    it "should use Foo.self for singleton methods of modules" do
-      class_name(class << Kernel; self; end).should == "Kernel.self"
-    end
-
-    it "should default to the .to_s if that's not possible" do
-      cls = Class.new
-      class_name(cls).should == cls.to_s
-    end
-
-    it "should default to .to_s.self" do
-      cls = Class.new
-      class_name(class << cls; self; end).should == "#{cls.to_s}.self"
-    end
-
-    it "should just be self for singleton classes of normal objects" do
-      class_name(class << "hi"; self; end).should == "self"
-    end
-  end
-
   describe "below ceiling" do
     it "should stop before Object by default" do
       mock_pry("cd Class.new{ def goo; end }.new", "ls").should.not =~ /Object/
@@ -55,7 +22,13 @@ describe "ls" do
     end
   end
 
-  describe "methods" do 
+  describe "help" do
+    it 'should show help with -h' do
+      mock_pry("ls -h").should =~ /Usage: ls/
+    end
+  end
+
+  describe "methods" do
     it "should show public methods by default" do
       mock_pry("ls Class.new{ def goo; end }.new").should =~ /goo/
     end
@@ -77,7 +50,7 @@ describe "ls" do
     it "should work for objects with an overridden method method" do
       require 'net/http'
       # This doesn't actually touch the network, promise!
-      mock_pry("ls Net::HTTP::Get.new('localhost')").should =~ /Net::HTTPGenericRequest methods/
+      mock_pry("ls Net::HTTP::Get.new('localhost')").should =~ /Net::HTTPGenericRequest#methods/
     end
   end
 
@@ -119,7 +92,7 @@ describe "ls" do
   describe "when no arguments given" do
     describe "when at the top-level" do
       # rubinius has a bug that means local_variables of "main" aren't reported inside eval()
-      unless defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
+      unless Pry::Helpers::BaseHelpers.rbx?
         it "should show local variables" do
           mock_pry("ls").should =~ /_pry_/
           mock_pry("arbitrar = 1", "ls").should =~ /arbitrar/

data/test/test_default_commands/test_shell.rb

@@ -1,18 +1,243 @@
 require 'helper'
 
 describe "Pry::DefaultCommands::Shell" do
+  describe "save-file" do
+    before do
+      @tf = Tempfile.new(["pry", ".py"])
+      @path = @tf.path
+    end
+
+    after do
+      @tf.close(true)
+    end
+
+    describe "-f" do
+      it 'should save a file to a file' do
+        f = Tempfile.new(["pry", ".py"])
+        path = f.path
+        f.write ":cute_horse"
+
+        redirect_pry_io(InputTester.new("save-file -f #{path} #{@path}",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+        File.read(@path).should == File.read(path)
+
+        f.close(true)
+      end
+    end
+
+    describe "-i" do
+      it 'should save input expressions to a file (single expression)' do
+        redirect_pry_io(InputTester.new(":horse_nostrils",
+                                        "save-file -i 1 #{@path}",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+        File.read(@path).should == ":horse_nostrils\n"
+      end
+
+      it 'should save input expressions to a file (range)' do
+        redirect_pry_io(InputTester.new(":horse_nostrils",
+                                        ":sucking_up_all_the_oxygen",
+                                        "save-file -i 1..2 #{@path}",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+        File.read(@path).should == ":horse_nostrils\n:sucking_up_all_the_oxygen\n"
+      end
+    end
+
+    describe "-m" do
+      before do
+        @o = Object.new
+        def @o.baby
+          :baby
+        end
+        def @o.bang
+          :bang
+        end
+      end
+
+      describe "single method" do
+        it 'should save a method to a file' do
+          redirect_pry_io(InputTester.new("save-file #{@path} -m baby",
+                                          "exit-all")) do
+            Pry.start(@o)
+          end
+          File.read(@path).should == Pry::Method.from_obj(@o, :baby).source
+        end
+
+        it 'should save a method to a file truncated by --lines' do
+          redirect_pry_io(InputTester.new("save-file #{@path} -m baby --lines 2..4",
+                                          "exit-all")) do
+            Pry.start(@o)
+          end
+
+          # must add 1 as first line of method is 1
+          File.read(@path).should == Pry::Method.from_obj(@o, :baby).source.lines.to_a[1..5].join
+        end
+      end
+
+      describe "multiple method" do
+        it 'should save multiple methods to a file' do
+          redirect_pry_io(InputTester.new("save-file #{@path} -m baby -m bang",
+                                          "exit-all")) do
+            Pry.start(@o)
+          end
+          File.read(@path).should == Pry::Method.from_obj(@o, :baby).source +
+            Pry::Method.from_obj(@o, :bang).source
+        end
+
+        it 'should save multiple methods to a file trucated by --lines' do
+          redirect_pry_io(InputTester.new("save-file #{@path} -m baby -m bang --lines 2..-2",
+                                          "exit-all")) do
+            Pry.start(@o)
+          end
+
+          # must add 1 as first line of method is 1
+          File.read(@path).should == (Pry::Method.from_obj(@o, :baby).source +
+            Pry::Method.from_obj(@o, :bang).source).lines.to_a[1..-2].join
+        end
+
+        it 'should save multiple methods to a file trucated by --lines 1 (single parameter, not range)' do
+          redirect_pry_io(InputTester.new("save-file #{@path} -m baby -m bang --lines 1",
+                                          "exit-all")) do
+            Pry.start(@o)
+          end
+
+          # must add 1 as first line of method is 1
+          File.read(@path).should == (Pry::Method.from_obj(@o, :baby).source +
+            Pry::Method.from_obj(@o, :bang).source).lines.to_a[0]
+        end
+
+      end
+
+    end
+
+    describe "overwrite by default (no --append)" do
+      it 'should overwrite specified file with new input' do
+        redirect_pry_io(InputTester.new(":horse_nostrils",
+                                        "save-file -i 1 #{@path}",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+
+        redirect_pry_io(InputTester.new(":sucking_up_all_the_oxygen",
+                                        "save-file -i 1 #{@path}",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+
+        File.read(@path).should == ":sucking_up_all_the_oxygen\n"
+      end
+
+    end
+
+    describe "--append" do
+      it 'should append to end of specified file' do
+        redirect_pry_io(InputTester.new(":horse_nostrils",
+                                        "save-file -i 1 #{@path}",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+
+        redirect_pry_io(InputTester.new(":sucking_up_all_the_oxygen",
+                                        "save-file -i 1 #{@path} -a",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+
+        File.read(@path).should == ":horse_nostrils\n:sucking_up_all_the_oxygen\n"
+      end
+    end
+
+    describe "-c" do
+      it 'should save a command to a file' do
+        redirect_pry_io(InputTester.new("save-file #{@path} -c show-method",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+        cmd = Pry::Method.new(Pry.commands.find_command("show-method").block)
+        File.read(@path).should == Pry::Code.from_method(cmd).to_s
+      end
+    end
+
+    describe "combined options" do
+      before do
+        @o = Object.new
+        def @o.baby
+          :baby
+        end
+      end
+
+      it 'should save input cache and a method to a file (in that order)' do
+        redirect_pry_io(InputTester.new(":horse_nostrils",
+                                        "save-file -i 1 -m baby #{@path}",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+        File.read(@path).should == ":horse_nostrils\n" + Pry::Method.from_obj(@o, :baby).source
+      end
+
+      it 'should select a portion to save using --lines' do
+        redirect_pry_io(InputTester.new(":horse_nostrils",
+                                        "save-file -i 1 -m baby #{@path} --lines 2..-2",
+                                        "exit-all")) do
+          Pry.start(@o)
+        end
+        File.read(@path).should == (":horse_nostrils\n" + Pry::Method.from_obj(@o, :baby).source).lines.to_a[1..-2].join
+      end
+    end
+  end
+
   describe "cat" do
 
     describe "on receiving a file that does not exist" do
       it 'should display an error message' do
-        mock_pry("cat supercalifragilicious66").should =~ /Could not find file/
+        mock_pry("cat supercalifragilicious66").should =~ /Cannot open/
+      end
+    end
+
+    describe "with --in" do
+      it 'should display the last few expressions with indices' do
+        output = mock_pry("10", "20", "cat --in")
+        output.should =~ /^1:/
+        output.should =~ /^  10/
+        output.should =~ /^2:/
+        output.should =~ /^  20/
+      end
+    end
+
+    describe "with --in 1" do
+      it 'should display the first expression with no index' do
+        output = mock_pry("10", "20", "cat --in 1")
+        output.should.not =~ /^\d+:/
+        output.should =~ /^10/
+      end
+    end
+
+    describe "with --in -1" do
+      it 'should display the last expression with no index' do
+        output = mock_pry("10", "20", "cat --in -1")
+        output.should.not =~ /^\d+:/
+        output.should =~ /^20/
+      end
+    end
+
+    describe "with --in 1..2" do
+      it 'should display the given range with indices, omitting nils' do
+        output = mock_pry("10", "20", "cat --ex", ":hello", "cat --in 1..4")
+        output.should =~ /^1:/
+        output.should.not =~ /^3:/
+        output.should =~ /^  :hello/
       end
     end
 
     # this doesnt work so well on rbx due to differences in backtrace
     # so we currently skip rbx until we figure out a workaround
     describe "with --ex" do
-      if !rbx?
+      if !Pry::Helpers::BaseHelpers.rbx?
         it 'cat --ex should correctly display code that generated exception even if raised in repl' do
           mock_pry("this raises error", "cat --ex").should =~ /\d+:(\s*) this raises error/
         end
@@ -30,7 +255,7 @@ describe "Pry::DefaultCommands::Shell" do
         temp_file do |f|
           f << "bt number 1"
           f.flush
-          pry_instance.last_exception = MockPryException.new("#{f.path}:1", "x", "x")
+          pry_instance.last_exception = mock_exception("#{f.path}:1", "x", "x")
           pry_instance.rep(self)
         end
 
@@ -43,7 +268,7 @@ describe "Pry::DefaultCommands::Shell" do
         temp_file do |f|
           f << "bt number 1"
           f.flush
-          pry_instance.last_exception = MockPryException.new("#{f.path}:1", "x", "x")
+          pry_instance.last_exception = mock_exception("#{f.path}:1", "x", "x")
           pry_instance.rep(self)
         end
 
@@ -56,37 +281,37 @@ describe "Pry::DefaultCommands::Shell" do
         temp_file do |f|
           f << "bt number 2"
           f.flush
-          pry_instance.last_exception = MockPryException.new("x", "#{f.path}:1", "x")
+          pry_instance.last_exception = mock_exception("x", "#{f.path}:1", "x")
           pry_instance.rep(self)
         end
 
         str_output.string.should =~ /bt number 2/
       end
 
-      it 'should cat third level of backtrace when --ex 2 used ' do
+      it 'should cat third level of backtrace when --ex 2 used' do
         pry_instance = Pry.new(:input => StringIO.new("cat --ex 2"), :output => str_output = StringIO.new)
 
         temp_file do |f|
           f << "bt number 3"
           f.flush
-          pry_instance.last_exception = MockPryException.new("x", "x", "#{f.path}:1")
+          pry_instance.last_exception = mock_exception("x", "x", "#{f.path}:1")
           pry_instance.rep(self)
         end
 
         str_output.string.should =~ /bt number 3/
       end
 
-      it 'should show error when backtrace level out of bounds  ' do
+      it 'should show error when backtrace level out of bounds' do
         pry_instance = Pry.new(:input => StringIO.new("cat --ex 3"), :output => str_output = StringIO.new)
-        pry_instance.last_exception = MockPryException.new("x", "x", "x")
+        pry_instance.last_exception = mock_exception("x", "x", "x")
         pry_instance.rep(self)
-        str_output.string.should =~ /No Exception or Exception has no associated file/
+        str_output.string.should =~ /out of bounds/
       end
 
       it 'each successive cat --ex should show the next level of backtrace, and going past the final level should return to the first' do
         temp_files = []
         3.times do |i|
-          temp_files << Tempfile.new(['tmp', '*.rb'])
+          temp_files << Tempfile.new(['pry', '*.rb'])
           temp_files.last << "bt number #{i}"
           temp_files.last.flush
         end
@@ -94,7 +319,7 @@ describe "Pry::DefaultCommands::Shell" do
         pry_instance = Pry.new(:input => StringIO.new("cat --ex\n" * 4),
                                :output => (str_output = StringIO.new))
 
-        pry_instance.last_exception = MockPryException.new(*temp_files.map { |f| "#{f.path}:1" })
+        pry_instance.last_exception = mock_exception(*temp_files.map { |f| "#{f.path}:1" })
 
         3.times do |i|
           pry_instance.rep(self)
@@ -105,7 +330,9 @@ describe "Pry::DefaultCommands::Shell" do
         pry_instance.rep(self)
         str_output.string.should =~ /bt number 0/
 
-        temp_files.each(&:close)
+        temp_files.each do |file|
+          file.close(true)
+        end
       end
 
     end

data/test/test_hooks.rb

@@ -0,0 +1,490 @@
+require 'helper'
+
+describe Pry::Hooks do
+  before do
+    @hooks = Pry::Hooks.new
+  end
+
+  describe "adding a new hook" do
+    it 'should not execute hook while adding it' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name) { run = true }
+      run.should == false
+    end
+
+    it 'should not allow adding of a hook with a duplicate name' do
+      @hooks.add_hook(:test_hook, :my_name) {}
+
+      lambda { @hooks.add_hook(:test_hook, :my_name) {} }.should.raise ArgumentError
+    end
+
+    it 'should create a new hook with a block' do
+      @hooks.add_hook(:test_hook, :my_name) { }
+      @hooks.hook_count(:test_hook).should == 1
+    end
+
+    it 'should create a new hook with a callable' do
+      @hooks.add_hook(:test_hook, :my_name, proc { })
+      @hooks.hook_count(:test_hook).should == 1
+    end
+
+    it 'should use block if given both block and callable' do
+      run = false
+      foo = false
+      @hooks.add_hook(:test_hook, :my_name, proc { foo = true }) { run = true }
+      @hooks.hook_count(:test_hook).should == 1
+      @hooks.exec_hook(:test_hook)
+      run.should == true
+      foo.should == false
+    end
+
+    it 'should raise if not given a block or any other object' do
+      lambda { @hooks.add_hook(:test_hook, :my_name) }.should.raise ArgumentError
+    end
+
+    it 'should create multiple hooks for an event' do
+      @hooks.add_hook(:test_hook, :my_name) {}
+      @hooks.add_hook(:test_hook, :my_name2) {}
+      @hooks.hook_count(:test_hook).should == 2
+    end
+
+    it 'should return a count of 0 for an empty hook' do
+      @hooks.hook_count(:test_hook).should == 0
+    end
+  end
+
+  describe "Pry::Hooks#merge" do
+    describe "merge!" do
+      it 'should merge in the Pry::Hooks' do
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+        h2 = Pry::Hooks.new
+
+        h2.merge!(h1)
+        h2.get_hook(:test_hook, :testing).should == h1.get_hook(:test_hook, :testing)
+      end
+
+      it 'should not share merged elements with original' do
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+        h2 = Pry::Hooks.new
+
+        h2.merge!(h1)
+        h2.add_hook(:test_hook, :testing2) {}
+        h2.get_hook(:test_hook, :testing2).should.not == h1.get_hook(:test_hook, :testing2)
+      end
+
+      it 'should NOT overwrite hooks belonging to shared event in receiver' do
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+        callable = proc {}
+        h2 = Pry::Hooks.new.add_hook(:test_hook, :testing2, callable)
+
+        h2.merge!(h1)
+        h2.get_hook(:test_hook, :testing2).should == callable
+      end
+
+      it 'should overwrite identical hook in receiver' do
+        callable1 = proc { :one }
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing, callable1)
+        callable2 = proc { :two }
+        h2 = Pry::Hooks.new.add_hook(:test_hook, :testing, callable2)
+
+        h2.merge!(h1)
+        h2.get_hook(:test_hook, :testing).should == callable1
+        h2.hook_count(:test_hook).should == 1
+      end
+
+      it 'should preserve hook order' do
+        name = ""
+        h1 = Pry::Hooks.new
+        h1.add_hook(:test_hook, :testing3) { name << "h" }
+        h1.add_hook(:test_hook, :testing4) { name << "n" }
+
+        h2 = Pry::Hooks.new
+        h2.add_hook(:test_hook, :testing1) { name << "j" }
+        h2.add_hook(:test_hook, :testing2) { name << "o" }
+
+        h2.merge!(h1)
+        h2.exec_hook(:test_hook)
+
+        name.should == "john"
+      end
+
+      describe "merge" do
+        it 'should return a fresh, independent instance' do
+          h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = Pry::Hooks.new
+
+          h3 = h2.merge(h1)
+          h3.should.not == h1
+          h3.should.not == h2
+        end
+
+        it 'should contain hooks from original instance' do
+          h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = Pry::Hooks.new.add_hook(:test_hook2, :testing) {}
+
+          h3 = h2.merge(h1)
+          h3.get_hook(:test_hook, :testing).should == h1.get_hook(:test_hook, :testing)
+          h3.get_hook(:test_hook2, :testing).should == h2.get_hook(:test_hook2, :testing)
+        end
+
+        it 'should not affect original instances when new hooks are added' do
+          h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = Pry::Hooks.new.add_hook(:test_hook2, :testing) {}
+
+          h3 = h2.merge(h1)
+          h3.add_hook(:test_hook3, :testing) {}
+
+          h1.get_hook(:test_hook3, :testing).should == nil
+          h2.get_hook(:test_hook3, :testing).should == nil
+        end
+      end
+
+    end
+  end
+
+  describe "dupping a Pry::Hooks instance" do
+    it 'should share hooks with original' do
+      @hooks.add_hook(:test_hook, :testing) do
+        :none_such
+      end
+
+      hooks_dup = @hooks.dup
+      hooks_dup.get_hook(:test_hook, :testing).should == @hooks.get_hook(:test_hook, :testing)
+    end
+
+    it 'adding a new event to dupped instance should not affect original' do
+      @hooks.add_hook(:test_hook, :testing) { :none_such }
+      hooks_dup = @hooks.dup
+
+      hooks_dup.add_hook(:other_test_hook, :testing) { :okay_man }
+
+      hooks_dup.get_hook(:other_test_hook, :testing).should.not == @hooks.get_hook(:other_test_hook, :testing)
+    end
+
+    it 'adding a new hook to dupped instance should not affect original' do
+      @hooks.add_hook(:test_hook, :testing) { :none_such }
+      hooks_dup = @hooks.dup
+
+      hooks_dup.add_hook(:test_hook, :testing2) { :okay_man }
+
+      hooks_dup.get_hook(:test_hook, :testing2).should.not == @hooks.get_hook(:test_hook, :testing2)
+    end
+
+  end
+
+  describe "getting hooks" do
+    describe "get_hook" do
+      it 'should return the correct requested hook' do
+        run = false
+        fun = false
+        @hooks.add_hook(:test_hook, :my_name) { run = true }
+        @hooks.add_hook(:test_hook, :my_name2) { fun = true }
+        @hooks.get_hook(:test_hook, :my_name).call
+        run.should == true
+        fun.should == false
+      end
+
+      it 'should return nil if hook does not exist' do
+        @hooks.get_hook(:test_hook, :my_name).should == nil
+      end
+    end
+
+    describe "get_hooks" do
+      it 'should return a hash of hook names/hook functions for an event' do
+        hook1 = proc { 1 }
+        hook2 = proc { 2 }
+        @hooks.add_hook(:test_hook, :my_name1, hook1)
+        @hooks.add_hook(:test_hook, :my_name2, hook2)
+        hash = @hooks.get_hooks(:test_hook)
+        hash.size.should == 2
+        hash[:my_name1].should == hook1
+        hash[:my_name2].should == hook2
+      end
+
+      it 'should return an empty hash if no hooks defined' do
+        @hooks.get_hooks(:test_hook).should == {}
+      end
+    end
+  end
+
+  describe "clearing all hooks for an event" do
+    it 'should clear all hooks' do
+      @hooks.add_hook(:test_hook, :my_name) { }
+      @hooks.add_hook(:test_hook, :my_name2) { }
+      @hooks.add_hook(:test_hook, :my_name3) { }
+      @hooks.clear(:test_hook)
+      @hooks.hook_count(:test_hook).should == 0
+    end
+  end
+
+  describe "deleting a hook" do
+    it 'should successfully delete a hook' do
+      @hooks.add_hook(:test_hook, :my_name) {}
+      @hooks.delete_hook(:test_hook, :my_name)
+      @hooks.hook_count(:test_hook).should == 0
+    end
+
+    it 'should return the deleted hook' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name) { run = true }
+      @hooks.delete_hook(:test_hook, :my_name).call
+      run.should == true
+    end
+
+    it 'should return nil if hook does not exist' do
+      @hooks.delete_hook(:test_hook, :my_name).should == nil
+    end
+  end
+
+  describe "executing a hook" do
+    it 'should execute block hook' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name) { run = true }
+      @hooks.exec_hook(:test_hook)
+      run.should == true
+    end
+
+    it 'should execute proc hook' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name, proc { run = true })
+      @hooks.exec_hook(:test_hook)
+      run.should == true
+    end
+
+    it 'should execute a general callable hook' do
+      callable = Object.new.tap do |obj|
+        obj.instance_variable_set(:@test_var, nil)
+        class << obj
+          attr_accessor :test_var
+          def call() @test_var = true; end
+        end
+      end
+
+      @hooks.add_hook(:test_hook, :my_name, callable)
+      @hooks.exec_hook(:test_hook)
+      callable.test_var.should == true
+    end
+
+    it 'should execute all hooks for an event if more than one is defined' do
+      x = nil
+      y = nil
+      @hooks.add_hook(:test_hook, :my_name1) { y = true }
+      @hooks.add_hook(:test_hook, :my_name2) { x = true }
+      @hooks.exec_hook(:test_hook)
+      x.should == true
+      y.should == true
+    end
+
+    it 'should execute hooks in order' do
+      array = []
+      @hooks.add_hook(:test_hook, :my_name1) { array << 1 }
+      @hooks.add_hook(:test_hook, :my_name2) { array << 2 }
+      @hooks.add_hook(:test_hook, :my_name3) { array << 3 }
+      @hooks.exec_hook(:test_hook)
+      array.should == [1, 2, 3]
+    end
+
+    it 'return value of exec_hook should be that of last executed hook' do
+      @hooks.add_hook(:test_hook, :my_name1) { 1 }
+      @hooks.add_hook(:test_hook, :my_name2) { 2 }
+      @hooks.add_hook(:test_hook, :my_name3) { 3 }
+      @hooks.exec_hook(:test_hook).should == 3
+    end
+
+    it 'should add exceptions to the errors array' do
+      @hooks.add_hook(:test_hook, :foo1) { raise 'one' }
+      @hooks.add_hook(:test_hook, :foo2) { raise 'two' }
+      @hooks.add_hook(:test_hook, :foo3) { raise 'three' }
+      @hooks.exec_hook(:test_hook)
+      @hooks.errors.map(&:message).should == ['one', 'two', 'three']
+    end
+
+    it 'should return the last exception raised as the return value' do
+      @hooks.add_hook(:test_hook, :foo1) { raise 'one' }
+      @hooks.add_hook(:test_hook, :foo2) { raise 'two' }
+      @hooks.add_hook(:test_hook, :foo3) { raise 'three' }
+      @hooks.exec_hook(:test_hook).should == @hooks.errors.last
+    end
+  end
+
+  describe "integration tests" do
+    describe "when_started hook" do
+      it 'should yield options to the hook' do
+        options = nil
+        Pry.config.hooks.add_hook(:when_started, :test_hook) { |target, opt, _| options = opt }
+
+        redirect_pry_io(StringIO.new("exit"), out=StringIO.new) do
+          Pry.start binding, :hello => :baby
+        end
+        options[:hello].should == :baby
+
+        Pry.config.hooks.delete_hook(:when_started, :test_hook)
+      end
+
+      describe "target" do
+
+        it 'should yield the target, as a binding ' do
+          b = nil
+          Pry.config.hooks.add_hook(:when_started, :test_hook) { |target, opt, _| b = target }
+
+          redirect_pry_io(StringIO.new("exit"), out=StringIO.new) do
+            Pry.start 5, :hello => :baby
+          end
+
+          b.is_a?(Binding).should == true
+          Pry.config.hooks.delete_hook(:when_started, :test_hook)
+        end
+
+        it 'should yield the target to the hook' do
+          b = nil
+          Pry.config.hooks.add_hook(:when_started, :test_hook) { |target, opt, _| b = target }
+
+          redirect_pry_io(StringIO.new("exit"), out=StringIO.new) do
+            Pry.start 5, :hello => :baby
+          end
+
+          b.eval('self').should == 5
+          Pry.config.hooks.delete_hook(:when_started, :test_hook)
+        end
+      end
+
+      it 'should allow overriding of target (and binding_stack)' do
+        options = nil
+        o = Object.new
+        class << o; attr_accessor :value; end
+
+        Pry.config.hooks.add_hook(:when_started, :test_hook) { |target, opt, _pry_| _pry_.binding_stack = [Pry.binding_for(o)] }
+
+        redirect_pry_io(InputTester.new("@value = true","exit-all")) do
+          Pry.start binding, :hello => :baby
+        end
+
+        o.value.should == true
+        Pry.config.hooks.delete_hook(:when_started, :test_hook)
+      end
+
+    end
+
+    describe "after_session hook" do
+      it 'should always run, even if uncaught exception bubbles out of repl' do
+        o = OpenStruct.new
+        o.great_escape = Class.new(StandardError)
+
+        old_ew = Pry.config.exception_whitelist
+        Pry.config.exception_whitelist << o.great_escape
+
+        array = [1, 2, 3, 4, 5]
+
+        begin
+          redirect_pry_io(StringIO.new("raise great_escape"), out=StringIO.new) do
+            Pry.start o, :hooks => Pry::Hooks.new.add_hook(:after_session, :cleanup) { array = nil }
+          end
+        rescue => ex
+          exception = ex
+        end
+
+        # ensure that an exception really was raised and it broke out
+        # of the repl
+        exception.is_a?(o.great_escape).should == true
+
+        # check that after_session hook ran
+        array.should == nil
+
+        # cleanup after test
+        Pry.config.exception_whitelist = old_ew
+      end
+
+      describe "exceptions" do
+        before do
+          Pry.config.hooks.add_hook(:after_eval, :baddums){ raise "Baddums" }
+          Pry.config.hooks.add_hook(:after_eval, :simbads){ raise "Simbads" }
+        end
+
+        after do
+          Pry.config.hooks.delete_hook(:after_eval, :baddums)
+          Pry.config.hooks.delete_hook(:after_eval, :simbads)
+        end
+        it "should not raise exceptions" do
+          lambda{
+            mock_pry("1", "2", "3")
+          }.should.not.raise
+        end
+
+        it "should print out a notice for each exception raised" do
+          mock_pry("1").should =~ /after_eval hook failed: RuntimeError: Baddums\n.*after_eval hook failed: RuntimeError: Simbads/m
+        end
+      end
+    end
+  end
+
+  describe "anonymous hooks" do
+    it 'should allow adding of hook without a name' do
+      @hooks.add_hook(:test_hook, nil) {}
+      @hooks.hook_count(:test_hook).should == 1
+    end
+
+    it 'should only allow one anonymous hook to exist' do
+      @hooks.add_hook(:test_hook, nil) {  }
+      @hooks.add_hook(:test_hook, nil) {  }
+      @hooks.hook_count(:test_hook).should == 1
+    end
+
+    it 'should execute most recently added anonymous hook' do
+      x = nil
+      y = nil
+      @hooks.add_hook(:test_hook, nil) { y = 1 }
+      @hooks.add_hook(:test_hook, nil) { x = 2 }
+      @hooks.exec_hook(:test_hook)
+      y.should == nil
+      x.should == 2
+    end
+  end
+
+  describe "deprecated hash-based API" do
+    after do
+      Pry.config.hooks.clear_all if Pry.config.hooks
+    end
+
+    describe "Pry.config.hooks" do
+      it 'should allow a hash-assignment' do
+        Pry.config.hooks = { :before_session => proc { :hello } }
+        Pry.config.hooks.get_hook(:before_session, nil).call.should == :hello
+      end
+
+      describe "Pry.config.hooks[]" do
+        it 'should return the only anonymous hook' do
+          Pry.config.hooks = { :before_session => proc { :hello } }
+          Pry.config.hooks[:before_session].call.should == :hello
+        end
+
+        it 'should add an anonymous hook when using Pry.config.hooks[]=' do
+          Pry.config.hooks[:before_session] = proc { :bing }
+          Pry.config.hooks.hook_count(:before_session).should == 1
+        end
+
+        it 'should add overwrite previous anonymous hooks with new one when calling Pry.config.hooks[]= multiple times' do
+          x = nil
+          Pry.config.hooks[:before_session] = proc { x = 1 }
+          Pry.config.hooks[:before_session] = proc { x = 2 }
+
+          Pry.config.hooks.exec_hook(:before_session)
+          Pry.config.hooks.hook_count(:before_session).should == 1
+          x.should == 2
+        end
+      end
+    end
+
+    describe "Pry.start" do
+      it 'should accept a hash for :hooks parameter' do
+
+        redirect_pry_io(InputTester.new("exit-all"), out=StringIO.new) do
+          Pry.start binding, :hooks => { :before_session => proc { |output, _, _| output.puts 'hello friend' } }
+        end
+
+        out.string.should =~ /hello friend/
+      end
+
+    end
+  end
+
+end