pry 0.9.7.4 → 0.9.8pre2

data/test/test_default_commands/test_context.rb

@@ -2,9 +2,9 @@ require 'helper'
 
 describe "Pry::DefaultCommands::Context" do
   describe "exit-all" do
-    it 'should break out of the repl loop of Pry instance (returning target of session)' do
+    it 'should break out of the repl loop of Pry instance and return nil' do
       redirect_pry_io(InputTester.new("exit-all"), StringIO.new) do
-        Pry.new.repl(0).should == 0
+        Pry.new.repl(0).should == nil
       end
     end
 
@@ -31,6 +31,21 @@ describe "Pry::DefaultCommands::Context" do
     end
   end
 
+  describe "whereami" do
+    it 'should work with methods that have been undefined' do
+      class Cor
+        def blimey!
+          Cor.send :undef_method, :blimey!
+          # using [.] so the regex doesn't match itself
+          mock_pry(binding, 'whereami').should =~ /self[.]blimey!/
+        end
+      end
+
+      Cor.new.blimey!
+      Object.remove_const(:Cor)
+    end
+  end
+
   describe "exit" do
     it 'should pop a binding with exit' do
       b = Pry.binding_for(:outer)
@@ -44,7 +59,7 @@ describe "Pry::DefaultCommands::Context" do
     end
 
     it 'should break out of the repl loop of Pry instance when binding_stack has only one binding with exit' do
-      Pry.start(0, :input => StringIO.new("exit")).should == 0
+      Pry.start(0, :input => StringIO.new("exit")).should == nil
     end
 
     it 'should break out of the repl loop of Pry instance when binding_stack has only one binding with exit, and return user-given value' do
@@ -127,7 +142,7 @@ describe "Pry::DefaultCommands::Context" do
     end
 
     it 'should break out of the repl loop of Pry instance when binding_stack has only one binding with cd ..' do
-      Pry.start(0, :input => StringIO.new("cd ..")).should == 0
+      Pry.start(0, :input => StringIO.new("cd ..")).should == nil
     end
 
     it 'should break out to outer-most session with cd /' do

data/test/test_default_commands/test_input.rb

@@ -154,7 +154,7 @@ describe "Pry::DefaultCommands::Input" do
       b = binding
       b.eval('x = "\"hello\""')
       redirect_pry_io(InputTester.new("play x", "exit-all"), str_output = StringIO.new) do
-        Pry.start b, :hooks => {}
+        Pry.start b, :hooks => Pry::Hooks.new
       end
       str_output.string.should =~ /hello/
     end
@@ -163,7 +163,7 @@ describe "Pry::DefaultCommands::Input" do
       b = binding
       b.eval('x = "\"hello\"\n\"goodbye\"\n\"love\""')
       redirect_pry_io(InputTester.new("play x --lines 1", "exit-all"), str_output = StringIO.new) do
-        Pry.start b, :hooks => {}
+        Pry.start b, :hooks => Pry::Hooks.new
       end
       str_output.string.should =~ /hello/
       str_output.string.should.not =~ /love/

data/test/test_default_commands/test_introspection.rb

@@ -48,7 +48,7 @@ describe "Pry::DefaultCommands::Introspection" do
         end
 
         it "should reload the file if it is a ruby file" do
-          tf = Tempfile.new(["tmp", ".rb"])
+          tf = Tempfile.new(["pry", ".rb"])
           path = tf.path
 
           mock_pry("edit #{path}", "$rand").should =~ /#{@rand}/
@@ -57,7 +57,7 @@ describe "Pry::DefaultCommands::Introspection" do
         end
 
         it "should not reload the file if it is not a ruby file" do
-          tf = Tempfile.new(["tmp", ".py"])
+          tf = Tempfile.new(["pry", ".py"])
           path = tf.path
 
           mock_pry("edit #{path}", "$rand").should.not =~ /#{@rand}/
@@ -66,7 +66,7 @@ describe "Pry::DefaultCommands::Introspection" do
         end
 
         it "should not reload a ruby file if -n is given" do
-          tf = Tempfile.new(["tmp", ".rb"])
+          tf = Tempfile.new(["pry", ".rb"])
           path = tf.path
 
           mock_pry("edit -n #{path}", "$rand").should.not =~ /#{@rand}/
@@ -75,7 +75,7 @@ describe "Pry::DefaultCommands::Introspection" do
         end
 
         it "should reload a non-ruby file if -r is given" do
-          tf = Tempfile.new(["tmp", ".pryrc"])
+          tf = Tempfile.new(["pry", ".pryrc"])
           path = tf.path
 
           mock_pry("edit -r #{path}", "$rand").should =~ /#{@rand}/
@@ -87,7 +87,7 @@ describe "Pry::DefaultCommands::Introspection" do
 
     describe "with --ex" do
       before do
-        @tf = Tempfile.new(["tmp", ".rb"])
+        @tf = Tempfile.new(["pry", ".rb"])
         @path = @tf.path
         @tf << "1\n2\nraise RuntimeError"
         @tf.flush
@@ -254,6 +254,10 @@ describe "Pry::DefaultCommands::Introspection" do
       str_output.string.should =~ /def sample/
     end
 
+    it 'should output help' do
+      mock_pry('show-method -h').should =~ /Usage: show-method/
+    end
+
     it 'should output a method\'s source with line numbers' do
       str_output = StringIO.new
       redirect_pry_io(InputTester.new("show-method -l sample_method", "exit-all"), str_output) do
@@ -316,6 +320,59 @@ describe "Pry::DefaultCommands::Introspection" do
       str_output.string.should =~ /Mr flibble/
     end
 
+    it "should find instance methods with -M" do
+      c = Class.new{ def moo; "ve over!"; end }
+      mock_pry(binding, "cd c","show-method -M moo").should =~ /ve over/
+    end
+
+    it "should not find instance methods with -m" do
+      c = Class.new{ def moo; "ve over!"; end }
+      mock_pry(binding, "cd c", "show-method -m moo").should =~ /could not be found/
+    end
+
+    it "should find normal methods with -m" do
+      c = Class.new{ def self.moo; "ve over!"; end }
+      mock_pry(binding, "cd c", "show-method -m moo").should =~ /ve over/
+    end
+
+    it "should not find normal methods with -M" do
+      c = Class.new{ def self.moo; "ve over!"; end }
+      mock_pry(binding, "cd c", "show-method -M moo").should =~ /could not be found/
+    end
+
+    it "should find normal methods with no -M or -m" do
+      c = Class.new{ def self.moo; "ve over!"; end }
+      mock_pry(binding, "cd c", "show-method moo").should =~ /ve over/
+    end
+
+    it "should find instance methods with no -M or -m" do
+      c = Class.new{ def moo; "ve over!"; end }
+      mock_pry(binding, "cd c", "show-method moo").should =~ /ve over/
+    end
+
+    it "should find super methods" do
+      class Foo
+        def foo(*bars)
+          :super_wibble
+        end
+      end
+      o = Foo.new
+      Object.remove_const(:Foo)
+      def o.foo(*bars)
+        :wibble
+      end
+
+      mock_pry(binding, "show-method --super o.foo").should =~ /:super_wibble/
+
+    end
+
+    it "should not raise an exception when a non-extant super method is requested" do
+      o = Object.new
+      def o.foo(*bars); end
+
+      mock_pry(binding, "show-method --super o.foo").should =~ /'self.foo' has no super method/
+    end
+
     # dynamically defined method source retrieval is only supported in
     # 1.9 - where Method#source_location is native
     if RUBY_VERSION =~ /1.9/
@@ -364,7 +421,7 @@ describe "Pry::DefaultCommands::Introspection" do
   describe "edit-method" do
     describe "on a method defined in a file" do
       before do
-        @tempfile = Tempfile.new(['tmp', '*.rb'])
+        @tempfile = Tempfile.new(['pry', '*.rb'])
         @tempfile.puts <<-EOS
           module A
             def a

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
 

data/test/test_default_commands/test_shell.rb

@@ -9,6 +9,41 @@ describe "Pry::DefaultCommands::Shell" do
       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
@@ -86,7 +121,7 @@ describe "Pry::DefaultCommands::Shell" do
       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

data/test/test_hooks.rb

@@ -0,0 +1,175 @@
+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 "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
+  end
+end