pry 0.9.6.2 → 0.9.7

data/test/test_command_set.rb

@@ -3,6 +3,7 @@ require 'helper'
 describe Pry::CommandSet do
   before do
     @set = Pry::CommandSet.new
+    @ctx = Pry::CommandContext.new
   end
 
   it 'should call the block used for the command when it is called' do
@@ -11,7 +12,7 @@ describe Pry::CommandSet do
       run = true
     end
 
-    @set.run_command nil, 'foo'
+    @set.run_command @ctx, 'foo'
     run.should == true
   end
 
@@ -20,21 +21,23 @@ describe Pry::CommandSet do
       args.should == [1, 2, 3]
     end
 
-    @set.run_command nil, 'foo', 1, 2, 3
+    @set.run_command @ctx, 'foo', 1, 2, 3
   end
 
   it 'should use the first argument as self' do
+    ctx = @ctx
+
     @set.command 'foo' do
-      self.should == true
+      self.should == ctx
     end
 
-    @set.run_command true, 'foo'
+    @set.run_command @ctx, 'foo'
   end
 
   it 'should raise an error when calling an undefined command' do
     @set.command('foo') {}
     lambda {
-      @set.run_command nil, 'bar'
+      @set.run_command @ctx, 'bar'
     }.should.raise(Pry::NoCommandError)
   end
 
@@ -43,7 +46,7 @@ describe Pry::CommandSet do
     @set.delete 'foo'
 
     lambda {
-      @set.run_command nil, 'foo'
+      @set.run_command @ctx, 'foo'
     }.should.raise(Pry::NoCommandError)
   end
 
@@ -57,11 +60,11 @@ describe Pry::CommandSet do
 
     @set.import_from(other_set, 'foo')
 
-    @set.run_command nil, 'foo'
+    @set.run_command @ctx, 'foo'
     run.should == true
 
     lambda {
-      @set.run_command nil, 'bar'
+      @set.run_command @ctx, 'bar'
     }.should.raise(Pry::NoCommandError)
   end
 
@@ -75,8 +78,8 @@ describe Pry::CommandSet do
 
     @set.import other_set
 
-    @set.run_command nil, 'foo'
-    @set.run_command nil, 'bar'
+    @set.run_command @ctx, 'foo'
+    @set.run_command @ctx, 'bar'
     run.should == [true, true]
   end
 
@@ -84,7 +87,7 @@ describe Pry::CommandSet do
     run = false
     @set.command('foo') { run = true }
 
-    Pry::CommandSet.new(@set).run_command nil, 'foo'
+    Pry::CommandSet.new(@set).run_command @ctx, 'foo'
     run.should == true
   end
 
@@ -101,7 +104,7 @@ describe Pry::CommandSet do
     @set.commands['bar'].name.should == 'bar'
     @set.commands['bar'].description.should == ''
 
-    @set.run_command nil, 'bar'
+    @set.run_command @ctx, 'bar'
     run.should == true
   end
 
@@ -114,17 +117,17 @@ describe Pry::CommandSet do
 
   it 'should return Pry::CommandContext::VOID_VALUE for commands by default' do
     @set.command('foo') { 3 }
-    @set.run_command(nil, 'foo').should == Pry::CommandContext::VOID_VALUE
+    @set.run_command(@ctx, 'foo').should == Pry::CommandContext::VOID_VALUE
   end
 
   it 'should be able to keep return values' do
     @set.command('foo', '', :keep_retval => true) { 3 }
-    @set.run_command(nil, 'foo').should == 3
+    @set.run_command(@ctx, 'foo').should == 3
   end
 
   it 'should be able to keep return values, even if return value is nil' do
     @set.command('foo', '', :keep_retval => true) { nil }
-    @set.run_command(nil, 'foo').should == nil
+    @set.run_command(@ctx, 'foo').should == nil
   end
 
   it 'should be able to have its own helpers' do
@@ -136,7 +139,7 @@ describe Pry::CommandSet do
       def my_helper; end
     end
 
-    @set.run_command(Pry::CommandContext.new, 'foo')
+    @set.run_command(@ctx, 'foo')
     Pry::CommandContext.new.should.not.respond_to :my_helper
   end
 
@@ -154,7 +157,7 @@ describe Pry::CommandSet do
       def my_other_helper; end
     end
 
-    @set.run_command(Pry::CommandContext.new, 'foo')
+    @set.run_command(@ctx, 'foo')
   end
 
   it 'should import helpers from imported sets' do
@@ -166,7 +169,7 @@ describe Pry::CommandSet do
 
     @set.import imported_set
     @set.command('foo') { should.respond_to :imported_helper_method }
-    @set.run_command(Pry::CommandContext.new, 'foo')
+    @set.run_command(@ctx, 'foo')
   end
 
   it 'should import helpers even if only some commands are imported' do
@@ -180,7 +183,7 @@ describe Pry::CommandSet do
 
     @set.import_from imported_set, 'bar'
     @set.command('foo') { should.respond_to :imported_helper_method }
-    @set.run_command(Pry::CommandContext.new, 'foo')
+    @set.run_command(@ctx, 'foo')
   end
 
   it 'should provide a :listing for a command that defaults to its name' do
@@ -194,12 +197,11 @@ describe Pry::CommandSet do
   end
 
   it "should provide a 'help' command" do
-    context = Pry::CommandContext.new
-    context.command_set = @set
-    context.output = StringIO.new
+    @ctx.command_set = @set
+    @ctx.output = StringIO.new
 
     lambda {
-      @set.run_command(context, 'help')
+      @set.run_command(@ctx, 'help')
     }.should.not.raise
   end
 
@@ -209,13 +211,12 @@ describe Pry::CommandSet do
     @set.command 'moo', "Mooerizes" do; end
     @set.command 'boo', "Booerizes" do; end
 
-    context = Pry::CommandContext.new
-    context.command_set = @set
-    context.output = StringIO.new
+    @ctx.command_set = @set
+    @ctx.output = StringIO.new
 
-    @set.run_command(context, 'help')
+    @set.run_command(@ctx, 'help')
 
-    doc = context.output.string
+    doc = @ctx.output.string
 
     order = [doc.index("boo"),
              doc.index("foo"),

data/test/test_default_commands/test_documentation.rb

@@ -10,16 +10,6 @@ describe "Pry::DefaultCommands::Documentation" do
 
       str_output.string.should =~ /sample doc/
     end
-    
-    it 'should output multiple methods\' documentation' do
-      str_output = StringIO.new
-      redirect_pry_io(InputTester.new("show-doc sample_method another_sample_method", "exit-all"), str_output) do
-        pry
-      end
-
-      str_output.string.should =~ /sample doc/
-      str_output.string.should =~ /another sample doc/
-    end
 
     it 'should output a method\'s documentation if inside method without needing to use method name' do
       $str_output = StringIO.new
@@ -37,5 +27,28 @@ describe "Pry::DefaultCommands::Documentation" do
       $str_output.string.should =~ /sample comment/
       $str_output = 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
+      }
+
+      o = d.new
+
+      # 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
   end
 end

data/test/test_default_commands/test_introspection.rb

@@ -254,16 +254,6 @@ describe "Pry::DefaultCommands::Introspection" do
       str_output.string.should =~ /def sample/
     end
 
-    it 'should output multiple methods\' sources' do
-      str_output = StringIO.new
-      redirect_pry_io(InputTester.new("show-method sample_method another_sample_method", "exit-all"), str_output) do
-        pry
-      end
-
-      str_output.string.should =~ /def sample/
-      str_output.string.should =~ /def another_sample/
-    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
@@ -312,6 +302,20 @@ describe "Pry::DefaultCommands::Introspection" do
       $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
+
     # dynamically defined method source retrieval is only supported in
     # 1.9 - where Method#source_location is native
     if RUBY_VERSION =~ /1.9/
@@ -366,6 +370,10 @@ describe "Pry::DefaultCommands::Introspection" do
             def a
               :yup
             end
+
+            def b
+              :kinda
+            end
           end
 
           class X
@@ -378,6 +386,11 @@ describe "Pry::DefaultCommands::Introspection" do
             def x
               :nope
             end
+
+            def b
+              super
+            end
+            alias c b
           end
         EOS
         @tempfile.flush
@@ -404,19 +417,19 @@ describe "Pry::DefaultCommands::Introspection" do
         it "should correctly find a class method" do
           mock_pry("edit-method X.x")
           @file.should == @tempfile.path
-          @line.should == 10
+          @line.should == 14
         end
 
         it "should correctly find an instance method" do
           mock_pry("edit-method X#x")
           @file.should == @tempfile.path
-          @line.should == 14
+          @line.should == 18
         end
 
         it "should correctly find a method on an instance" do
           mock_pry("x = X.new", "edit-method x.x")
           @file.should == @tempfile.path
-          @line.should == 14
+          @line.should == 18
         end
 
         it "should correctly find a method from a module" do
@@ -424,6 +437,12 @@ describe "Pry::DefaultCommands::Introspection" do
           @file.should == @tempfile.path
           @line.should == 2
         end
+
+        it "should correctly find an aliased method" do
+          mock_pry("edit-method X#c")
+          @file.should == @tempfile.path
+          @line.should == 22
+        end
       end
 
       describe 'with -p' do
@@ -474,6 +493,32 @@ describe "Pry::DefaultCommands::Introspection" do
           X.new.a.should == :maybe
         end
       end
+
+      describe 'on an aliased method' do
+        before do
+          @old_editor = Pry.config.editor
+          Pry.config.editor = lambda do |file, line|
+            lines = File.read(file).lines.to_a
+            lines[1] = '"#{super}aa".to_sym' + "\n"
+            File.open(file, 'w') do |f|
+              f.write(lines.join)
+            end
+            nil
+          end
+        end
+        after do
+          Pry.config.editor = @old_editor
+        end
+
+        it "should change the alias, but not the original, without breaking super" do
+          mock_pry("edit-method -p X#c")
+
+          Pry::Method.from_str("X#c").alias?.should == true
+
+          X.new.b.should == :kinda
+          X.new.c.should == :kindaaa
+        end
+      end
     end
   end
 

data/test/test_default_commands/test_ls.rb

@@ -0,0 +1,148 @@
+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/
+      mock_pry("cd Class.new{ def goo; end }", "ls -M").should.not =~ /Object/
+    end
+
+    it "should include object if -v is given" do
+      mock_pry("cd Class.new{ def goo; end }.new", "ls -m -v").should =~ /Object/
+      mock_pry("cd Class.new{ def goo; end }", "ls -vM").should =~ /Object/
+    end
+
+    it "should include super-classes by default" do
+      mock_pry("cd Class.new(Class.new{ def goo; end }).new", "ls").should =~ /goo/
+      mock_pry("cd Class.new(Class.new{ def goo; end })", "ls -M").should =~ /goo/
+    end
+
+    it "should not include super-classes when -q is given" do
+      mock_pry("cd Class.new(Class.new{ def goo; end }).new", "ls -q").should.not =~ /goo/
+      mock_pry("cd Class.new(Class.new{ def goo; end })", "ls -M -q").should.not =~ /goo/
+    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
+
+    it "should not show protected/private by default" do
+      mock_pry("ls -M Class.new{ def goo; end; private :goo }").should.not =~ /goo/
+      mock_pry("ls Class.new{ def goo; end; protected :goo }.new").should.not =~ /goo/
+    end
+
+    it "should show public methods with -p" do
+      mock_pry("ls -p Class.new{ def goo; end }.new").should =~ /goo/
+    end
+
+    it "should show protected/private methods with -p" do
+      mock_pry("ls -pM Class.new{ def goo; end; protected :goo }").should =~ /goo/
+      mock_pry("ls -p Class.new{ def goo; end; private :goo }.new").should =~ /goo/
+    end
+
+    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/
+    end
+  end
+
+  describe "constants" do
+    it "should show constants defined on the current module" do
+      mock_pry("class TempFoo1; BARGHL = 1; end", "ls TempFoo1").should =~ /BARGHL/
+    end
+
+    it "should not show constants defined on parent modules by default" do
+      mock_pry("class TempFoo2; LHGRAB = 1; end; class TempFoo3 < TempFoo2; BARGHL = 1; end", "ls TempFoo3").should.not =~ /LHGRAB/
+    end
+
+    it "should show constants defined on ancestors with -v" do
+      mock_pry("class TempFoo4; LHGRAB = 1; end; class TempFoo5 < TempFoo4; BARGHL = 1; end", "ls -v TempFoo5").should =~ /LHGRAB/
+    end
+
+    it "should not autoload constants!" do
+      autoload :McflurgleTheThird, "/tmp/this-file-d000esnat-exist.rb"
+      lambda{ mock_pry("ls -c") }.should.not.raise
+    end
+  end
+
+  describe "grep" do
+    it "should reduce the number of outputted things" do
+      mock_pry("ls -c").should =~ /ArgumentError/
+      mock_pry("ls -c --grep Run").should.not =~ /ArgumentError/
+    end
+    it "should still output matching things" do
+      mock_pry("ls -c --grep Run").should =~ /RuntimeError/
+    end
+  end
+
+  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/
+        it "should show local variables" do
+          mock_pry("ls").should =~ /_pry_/
+          mock_pry("arbitrar = 1", "ls").should =~ /arbitrar/
+        end
+      end
+    end
+
+    describe "when in a class" do
+      it "should show constants" do
+        mock_pry("class GeFromulate1; FOOTIFICATE=1.3; end", "cd GeFromulate1", "ls").should =~ /FOOTIFICATE/
+      end
+
+      it "should show class variables" do
+        mock_pry("class GeFromulate2; @@flurb=1.3; end", "cd GeFromulate2", "ls").should =~ /@@flurb/
+      end
+
+      it "should show methods" do
+        mock_pry("class GeFromulate3; def self.mooflight; end ; end", "cd GeFromulate3", "ls").should =~ /mooflight/
+      end
+    end
+
+    describe "when in an object" do
+      it "should show methods" do
+        mock_pry("cd Class.new{ def self.fooerise; end; self }", "ls").should =~ /fooerise/
+      end
+
+      it "should show instance variables" do
+        mock_pry("cd Class.new", "@alphooent = 1", "ls").should =~ /@alphooent/
+      end
+    end
+  end
+end