pry 0.9.8.4-i386-mingw32 → 0.9.9-i386-mingw32

data/test/test_default_commands/test_cd.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+describe 'Pry::DefaultCommands::CD' do
+  describe 'cd' do
+    # Regression test for ticket #516.
+    #it 'should be able to cd into the Object BasicObject.' do
+    #  mock_pry('cd BasicObject.new').should.not =~ /\Aundefined method `__binding__'/
+    #end
+    
+    # Regression test for ticket #516
+    # Possibly move higher up.
+    it 'should not fail with undefined BasicObject#is_a?' do
+      mock_pry('cd BasicObject.new').should.not =~ /undefined method `is_a\?'/
+    end
+  end
+end

data/test/test_default_commands/test_context.rb

@@ -44,6 +44,18 @@ describe "Pry::DefaultCommands::Context" do
       Cor.new.blimey!
       Object.remove_const(:Cor)
     end
+
+    it 'should work in objects with no method methods' do
+      class Cor
+        def blimey!
+          mock_pry(binding, 'whereami').should =~ /Cor[#]blimey!/
+        end
+
+        def method; "moo"; end
+      end
+      Cor.new.blimey!
+      Object.remove_const(:Cor)
+    end
   end
 
   describe "exit" do
@@ -267,4 +279,53 @@ describe "Pry::DefaultCommands::Context" do
       $obj.should == :mon_ouie
     end
   end
+
+  describe "raise-up" do
+    it "should raise the exception with raise-up" do
+      redirect_pry_io(InputTester.new("raise NoMethodError", "raise-up NoMethodError"),StringIO.new) do
+        lambda { Pry.new.repl(0) }.should.raise NoMethodError
+      end
+    end
+
+    it "should raise an unamed exception with raise-up" do
+      redirect_pry_io(InputTester.new("raise 'stop'","raise-up 'noreally'"),StringIO.new) do
+        lambda { Pry.new.repl(0) }.should.raise RuntimeError, "noreally"
+      end
+    end
+
+    it "should eat the exception at the last new pry instance on raise-up" do
+      b = Pry.binding_for(:outer)
+      b.eval("x = :inner")
+
+      redirect_pry_io(InputTester.new("x.pry", "raise NoMethodError",
+        "$inner = self", "raise-up NoMethodError", "$outer = self", "exit-all"),StringIO.new) do
+        b.pry
+      end
+      $inner.should == :inner
+      $outer.should == :outer
+    end
+
+    it "should raise the most recently raised exception" do
+      lambda { mock_pry("raise NameError, 'homographery'","raise-up") }.should.raise NameError, 'homographery'
+    end
+
+    it "should allow you to cd up and (eventually) out" do
+      $deep = $inner = $outer = nil
+      b = Pry.binding_for(:outer)
+      b.eval("x = :inner")
+      redirect_pry_io(InputTester.new("cd x", "raise NoMethodError","$inner = self",
+        "deep = :deep", "cd deep","$deep = self","raise-up NoMethodError", "raise-up", "$outer = self", "raise-up", "exit-all"),StringIO.new) do
+        lambda { b.pry }.should.raise NoMethodError
+      end
+      $deep.should == :deep
+      $inner.should == :inner
+      $outer.should == :outer
+    end
+  end
+
+  describe "raise-up!" do
+    it "should jump immediately out of nested context's" do
+      lambda { mock_pry("cd 1", "cd 2", "cd 3", "raise-up! 'fancy that...'") }.should.raise RuntimeError, 'fancy that...'
+    end
+  end
 end

data/test/test_default_commands/test_documentation.rb

@@ -1,66 +1,186 @@
 require 'helper'
 
-describe "Pry::DefaultCommands::Documentation" do
-  describe "show-doc" do
-    it 'should output a method\'s documentation' do
-      redirect_pry_io(InputTester.new("show-doc sample_method", "exit-all"), str_output=StringIO.new) do
-        pry
+if !mri18_and_no_real_source_location?
+  describe "Pry::DefaultCommands::Documentation" do
+    describe "show-doc" do
+      it 'should output a method\'s documentation' do
+        redirect_pry_io(InputTester.new("show-doc sample_method", "exit-all"), str_output=StringIO.new) do
+          pry
+        end
+
+        str_output.string.should =~ /sample doc/
       end
 
-      str_output.string.should =~ /sample doc/
-    end
+      it 'should output a method\'s documentation with line numbers' do
+        redirect_pry_io(InputTester.new("show-doc sample_method -l", "exit-all"), str_output=StringIO.new) do
+          pry
+        end
 
-    it 'should output a method\'s documentation with line numbers' do
-      redirect_pry_io(InputTester.new("show-doc sample_method -l", "exit-all"), str_output=StringIO.new) do
-        pry
+        str_output.string.should =~ /\d: sample doc/
       end
 
-      str_output.string.should =~ /\d: sample doc/
-    end
+      it 'should output a method\'s documentation with line numbers (base one)' do
+        redirect_pry_io(InputTester.new("show-doc sample_method -b", "exit-all"), str_output=StringIO.new) do
+          pry
+        end
 
-    it 'should output a method\'s documentation with line numbers (base one)' do
-      redirect_pry_io(InputTester.new("show-doc sample_method -b", "exit-all"), str_output=StringIO.new) do
-        pry
+        str_output.string.should =~ /1: sample doc/
       end
 
-      str_output.string.should =~ /1: sample doc/
-    end
+      it 'should output a method\'s documentation if inside method without needing to use method name' do
+        o = Object.new
+
+        # sample comment
+        def o.sample
+          redirect_pry_io(InputTester.new("show-doc", "exit-all"), $out=StringIO.new) do
+            binding.pry
+          end
+        end
+        o.sample
+        $out.string.should =~ /sample comment/
+        $out = nil
+      end
+
+      it "should be able to find super methods" do
+
+        c = Class.new{
+          # classy initialize!
+          def initialize(*args); end
+        }
+
+        d = Class.new(c){
+          # grungy initialize??
+          def initialize(*args, &block); end
+        }
 
-    it 'should output a method\'s documentation if inside method without needing to use method name' do
-      o = Object.new
+        o = d.new
 
-      # sample comment
-      def o.sample
-        redirect_pry_io(InputTester.new("show-doc", "exit-all"), $out=StringIO.new) do
-          binding.pry
-       end
+        # instancey initialize!
+        def o.initialize; end
+
+        mock_pry(binding, "show-doc o.initialize").should =~ /instancey initialize/
+        mock_pry(binding, "show-doc --super o.initialize").should =~ /grungy initialize/
+        mock_pry(binding, "show-doc o.initialize -ss").should =~ /classy initialize/
+        mock_pry(binding, "show-doc --super o.initialize -ss").should == mock_pry("show-doc Object#initialize")
       end
-      o.sample
-      $out.string.should =~ /sample comment/
-      $out = nil
     end
 
-    it "should be able to find super methods" do
+    describe "on modules" do
+      before do
+        # god this is boring1
+        class ShowSourceTestClass
+          def alpha
+          end
+        end
+
+        # god this is boring2
+        module ShowSourceTestModule
+          def alpha
+          end
+        end
+
+        # god this is boring3
+        ShowSourceTestClassWeirdSyntax = Class.new do
+          def beta
+          end
+        end
+
+        # god this is boring4
+        ShowSourceTestModuleWeirdSyntax = Module.new do
+          def beta
+          end
+        end
+      end
+
+      after do
+        Object.remove_const :ShowSourceTestClass
+        Object.remove_const :ShowSourceTestClassWeirdSyntax
+        Object.remove_const :ShowSourceTestModule
+        Object.remove_const :ShowSourceTestModuleWeirdSyntax
+      end
 
-      c = Class.new{
-        # classy initialize!
-        def initialize(*args); end
-      }
+      describe "basic functionality, should show docs for top-level module definitions" do
+        it 'should show docs for a class' do
+          mock_pry("show-doc ShowSourceTestClass").should =~ /god this is boring1/
+        end
 
-      d = Class.new(c){
-        # grungy initialize??
-        def initialize(*args, &block); end
-      }
+        it 'should show docs for a module' do
+          mock_pry("show-doc ShowSourceTestModule").should =~ /god this is boring2/
+        end
 
-      o = d.new
+        it 'should show docs for a class when Const = Class.new syntax is used' do
+          mock_pry("show-doc ShowSourceTestClassWeirdSyntax").should =~ /god this is boring3/
+        end
 
-      # instancey initialize!
-      def o.initialize; end
+        it 'should show docs for a module when Const = Module.new syntax is used' do
+          mock_pry("show-doc ShowSourceTestModuleWeirdSyntax").should =~ /god this is boring4/
+        end
+      end
 
-      mock_pry(binding, "show-doc o.initialize").should =~ /instancey initialize/
-      mock_pry(binding, "show-doc --super o.initialize").should =~ /grungy initialize/
-      mock_pry(binding, "show-doc o.initialize -ss").should =~ /classy initialize/
-      mock_pry(binding, "show-doc --super o.initialize -ss").should == mock_pry("show-doc Object#initialize")
+      if !Pry::Helpers::BaseHelpers.mri_18?
+        describe "in REPL" do
+          it 'should find class defined in repl' do
+            mock_pry("# hello tobina", "class TobinaMyDog", "def woof", "end", "end", "show-doc TobinaMyDog").should =~ /hello tobina/
+            Object.remove_const :TobinaMyDog
+          end
+        end
+      end
+
+      it 'should lookup module name with respect to current context' do
+        constant_scope(:AlphaClass, :BetaClass) do
+
+          # top-level beta
+          class BetaClass
+            def alpha
+            end
+          end
+
+          class AlphaClass
+
+            # nested beta
+            class BetaClass
+              def beta
+              end
+            end
+          end
+
+          redirect_pry_io(InputTester.new("show-doc BetaClass", "exit-all"), out=StringIO.new) do
+            AlphaClass.pry
+          end
+
+          out.string.should =~ /nested beta/
+        end
+      end
+
+      it 'should lookup nested modules' do
+        constant_scope(:AlphaClass) do
+          class AlphaClass
+
+            # nested beta
+            class BetaClass
+              def beta
+              end
+            end
+          end
+
+          mock_pry("show-doc AlphaClass::BetaClass").should =~ /nested beta/
+        end
+      end
+
+      describe "show-doc -a" do
+        it 'should show the docs for all monkeypatches defined in different files' do
+
+          # local monkeypatch
+          class TestClassForShowSource
+            def beta
+            end
+          end
+
+          result = mock_pry("show-doc TestClassForShowSource -a")
+          result.should =~ /used by/
+          result.should =~ /local monkeypatch/
+        end
+      end
     end
   end
 end

data/test/test_default_commands/test_find_method.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+# we turn off the test for MRI 1.8 because our source_location hack
+# for C methods actually runs the methods - and since it runs ALL
+# methods (in an attempt to find a match) it runs 'exit' and aborts
+# the test, causing a failure. We should fix this in the future by
+# blacklisting certain methods for 1.8 MRI (such as exit, fork, and so on) 
+unless Pry::Helpers::BaseHelpers.mri_18?
+  MyKlass = Class.new do
+    def hello
+      "timothy"
+    end
+    def goodbye
+      "jenny"
+    end
+  end
+
+  describe "find-command" do
+    describe "find matching methods by name regex (-n option)" do
+      it "should find a method by regex" do
+        mock_pry("find-method hell MyKlass").should =~ /MyKlass.*?hello/m
+      end
+      
+      it "should NOT match a method that does not match the regex" do
+        mock_pry("find-method hell MyKlass").should.not =~ /MyKlass.*?goodbye/m
+      end
+    end
+
+    describe "find matching methods by content regex (-c option)" do
+      it "should find a method by regex" do
+        mock_pry("find-method -c timothy MyKlass").should =~ /MyKlass.*?hello/m
+      end
+
+      it "should NOT match a method that does not match the regex" do
+        mock_pry("find-method timothy MyKlass").should.not =~ /MyKlass.*?goodbye/m
+      end
+    end
+    
+  end
+
+  Object.remove_const(:MyKlass)
+end

data/test/test_default_commands/test_input.rb

@@ -347,6 +347,38 @@ describe "Pry::DefaultCommands::Input" do
       str_output.string.should =~ /x\n\d+:.*y\n\d+:.*z/
     end
 
+    it 'should apply --tail after --grep' do
+      @hist.push "print 1"
+      @hist.push "print 2"
+      @hist.push "puts  3"
+      @hist.push "print 4"
+      @hist.push "puts  5"
+
+      str_output = StringIO.new
+      redirect_pry_io(InputTester.new("hist --tail 2 --grep print", "exit-all"), str_output) do
+        pry
+      end
+
+      str_output.string.each_line.count.should == 2
+      str_output.string.should =~ /\d:.*?print 2\n\d:.*?print 4/
+    end
+
+    it 'should apply --head after --grep' do
+      @hist.push "puts  1"
+      @hist.push "print 2"
+      @hist.push "puts  3"
+      @hist.push "print 4"
+      @hist.push "print 5"
+
+      str_output = StringIO.new
+      redirect_pry_io(InputTester.new("hist --head 2 --grep print", "exit-all"), str_output) do
+        pry
+      end
+
+      str_output.string.each_line.count.should == 2
+      str_output.string.should =~ /\d:.*?print 2\n\d:.*?print 4/
+    end
+
     # strangeness in this test is due to bug in Readline::HISTORY not
     # always registering first line of input
     it 'should return first N lines in history with --head switch' do

data/test/test_default_commands/test_introspection.rb

@@ -83,6 +83,23 @@ describe "Pry::DefaultCommands::Introspection" do
           tf.close(true)
         end
       end
+
+      describe do
+        before do
+          @reloading = nil
+          Pry.config.editor = lambda do |file, line, reloading|
+            @file = file; @line = line; @reloading = reloading
+            nil
+          end
+        end
+
+        it "should pass the editor a reloading arg" do
+          mock_pry("edit foo.rb")
+          @reloading.should == true
+          mock_pry("edit -n foo.rb")
+          @reloading.should == false
+        end
+      end
     end
 
     describe "with --ex" do
@@ -244,203 +261,6 @@ describe "Pry::DefaultCommands::Introspection" do
     end
   end
 
-  describe "show-method" do
-    it 'should output a method\'s source' do
-      str_output = StringIO.new
-      redirect_pry_io(InputTester.new("show-method sample_method", "exit-all"), str_output) do
-        pry
-      end
-
-      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
-        pry
-      end
-
-      str_output.string.should =~ /\d+: def sample/
-    end
-
-    it 'should output a method\'s source with line numbers starting at 1' do
-      str_output = StringIO.new
-      redirect_pry_io(InputTester.new("show-method -b sample_method", "exit-all"), str_output) do
-        pry
-      end
-
-      str_output.string.should =~ /1: def sample/
-    end
-
-    it 'should output a method\'s source if inside method without needing to use method name' do
-      $str_output = StringIO.new
-
-      o = Object.new
-      def o.sample
-        redirect_pry_io(InputTester.new("show-method", "exit-all"), $str_output) do
-          binding.pry
-        end
-      end
-      o.sample
-
-      $str_output.string.should =~ /def o.sample/
-      $str_output = nil
-    end
-
-    it 'should output a method\'s source if inside method without needing to use method name, and using the -l switch' do
-      $str_output = StringIO.new
-
-      o = Object.new
-      def o.sample
-        redirect_pry_io(InputTester.new("show-method -l", "exit-all"), $str_output) do
-          binding.pry
-        end
-      end
-      o.sample
-
-      $str_output.string.should =~ /\d+: def o.sample/
-      $str_output = nil
-    end
-
-    it "should find methods even if there are spaces in the arguments" do
-      o = Object.new
-      def o.foo(*bars);
-        "Mr flibble"
-        self;
-      end
-
-      str_output = StringIO.new
-      redirect_pry_io(InputTester.new("show-method o.foo('bar', 'baz bam').foo", "exit-all"), str_output) do
-        binding.pry
-      end
-      str_output.string.should =~ /Mr flibble/
-    end
-
-    it "should find methods even if the object has an overridden method method" do
-      c = Class.new{
-        def method;
-          98
-        end
-      }
-
-      mock_pry(binding, "show-method c.new.method").should =~ /98/
-    end
-
-    it "should find instance_methods even if the class has an override instance_method method" do
-      c = Class.new{
-        def method;
-          98
-        end
-
-        def self.instance_method; 789; end
-      }
-
-      mock_pry(binding, "show-method c#method").should =~ /98/
-
-    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/
-      it 'should output a method\'s source for a method defined inside pry' do
-        str_output = StringIO.new
-        redirect_pry_io(InputTester.new("def dyna_method", ":testing", "end", "show-method dyna_method"), str_output) do
-          TOPLEVEL_BINDING.pry
-        end
-
-        str_output.string.should =~ /def dyna_method/
-        Object.remove_method :dyna_method
-      end
-
-      it 'should output a method\'s source for a method defined inside pry, even if exceptions raised before hand' do
-        str_output = StringIO.new
-        redirect_pry_io(InputTester.new("bad code", "123", "bad code 2", "1 + 2", "def dyna_method", ":testing", "end", "show-method dyna_method"), str_output) do
-          TOPLEVEL_BINDING.pry
-        end
-
-        str_output.string.should =~ /def dyna_method/
-        Object.remove_method :dyna_method
-      end
-
-      it 'should output an instance method\'s source for a method defined inside pry' do
-        str_output = StringIO.new
-        redirect_pry_io(InputTester.new("class A", "def yo", "end", "end", "show-method A#yo"), str_output) do
-          TOPLEVEL_BINDING.pry
-        end
-
-        str_output.string.should =~ /def yo/
-        Object.remove_const :A
-      end
-
-      it 'should output an instance method\'s source for a method defined inside pry using define_method' do
-        str_output = StringIO.new
-        redirect_pry_io(InputTester.new("class A", "define_method(:yup) {}", "end", "show-method A#yup"), str_output) do
-          TOPLEVEL_BINDING.pry
-        end
-
-        str_output.string.should =~ /define_method\(:yup\)/
-        Object.remove_const :A
-      end
-    end
-  end
-
   describe "edit-method" do
     describe "on a method defined in a file" do
       before do
@@ -471,6 +291,10 @@ describe "Pry::DefaultCommands::Introspection" do
               super
             end
             alias c b
+
+            def y?
+              :because
+            end
           end
         EOS
         @tempfile.flush
@@ -572,6 +396,13 @@ describe "Pry::DefaultCommands::Introspection" do
           X.instance_method(:a).owner.should == A
           X.new.a.should == :maybe
         end
+
+        it "should successfully replace a method with a question mark" do
+          mock_pry("edit-method -p X#y?")
+
+          X.instance_method(:y?).owner.should == X
+          X.new.y?.should == :maybe
+        end
       end
 
       describe 'on an aliased method' do
@@ -599,6 +430,28 @@ describe "Pry::DefaultCommands::Introspection" do
           X.new.c.should == :kindaaa
         end
       end
+
+      describe 'with three-arg editor' do
+        before do
+          @old_editor = Pry.config.editor
+          @file, @line, @reloading = nil, nil, nil
+          Pry.config.editor = lambda do |file, line, reloading|
+            @file = file; @line = line; @reloading = reloading
+            nil
+          end
+        end
+        after do
+          Pry.config.editor = @old_editor
+        end
+
+        it "should pass the editor a reloading arg" do
+          mock_pry('edit-method X.x')
+          @reloading.should == true
+          mock_pry('edit-method -n X.x')
+          @reloading.should == false
+        end
+      end
+
     end
   end