pry 0.9.10 → 0.9.11

data/spec/code_object_spec.rb

@@ -0,0 +1,277 @@
+require 'helper'
+
+describe Pry::CodeObject do
+  describe "basic lookups" do
+    before do
+      @obj = Object.new
+      def @obj.ziggy
+        "a flight of scarlet pigeons thunders round my thoughts"
+      end
+
+      class ClassyWassy
+        def piggy
+          binding
+        end
+      end
+
+      @p = Pry.new
+      @p.binding_stack = [binding]
+    end
+
+    after do
+      Object.remove_const(:ClassyWassy)
+    end
+
+    it 'should lookup methods' do
+      m = Pry::CodeObject.lookup("@obj.ziggy", @p)
+      m.is_a?(Pry::Method).should == true
+      m.name.to_sym.should == :ziggy
+    end
+
+    it 'should lookup modules' do
+      m = Pry::CodeObject.lookup("ClassyWassy", @p)
+      m.is_a?(Pry::WrappedModule).should == true
+      m.source.should =~ /piggy/
+    end
+
+    it 'should lookup procs' do
+      my_proc = proc { :hello }
+      @p.binding_stack = [binding]
+      m = Pry::CodeObject.lookup("my_proc", @p)
+      m.is_a?(Pry::Method).should == true
+      m.source.should =~ /hello/
+    end
+
+    describe 'commands lookup' do
+      before do
+        @p = Pry.new
+        @p.binding_stack = [binding]
+      end
+
+      it 'should return command class' do
+        @p.commands.command "jeremy-jones" do
+          "lobster"
+        end
+        m = Pry::CodeObject.lookup("jeremy-jones", @p)
+        (m <= Pry::Command).should == true
+        m.source.should =~ /lobster/
+      end
+
+      describe "class commands" do
+        before do
+          class LobsterLady < Pry::ClassCommand
+            match "lobster-lady"
+            description "nada."
+            def process
+              "lobster"
+            end
+          end
+        end
+
+        after do
+          Object.remove_const(:LobsterLady)
+        end
+
+        it 'should return Pry::ClassCommand class when looking up class command' do
+          Pry.commands.add_command(LobsterLady)
+          m = Pry::CodeObject.lookup("lobster-lady", @p)
+          (m <= Pry::ClassCommand).should == true
+          m.source.should =~ /class LobsterLady/
+          Pry.commands.delete("lobster-lady")
+        end
+
+        it 'should return Pry::WrappedModule when looking up command class directly (as a class, not as a command)' do
+          Pry.commands.add_command(LobsterLady)
+          m = Pry::CodeObject.lookup("LobsterLady", @p)
+          m.is_a?(Pry::WrappedModule).should == true
+          m.source.should =~ /class LobsterLady/
+          Pry.commands.delete("lobster-lady")
+        end
+      end
+
+      it 'looks up commands by :listing name as well' do
+        @p.commands.command /jeremy-.*/, "", :listing => "jeremy-baby" do
+          "lobster"
+        end
+        m = Pry::CodeObject.lookup("jeremy-baby", @p)
+        (m <= Pry::Command).should == true
+        m.source.should =~ /lobster/
+      end
+
+      it 'finds nothing when passing nil as the first argument' do
+        Pry::CodeObject.lookup(nil, @p).should == nil
+      end
+
+    end
+
+    it 'should lookup instance methods defined on classes accessed via local variable' do
+      o = Class.new do
+        def princess_bubblegum
+          "mathematic!"
+        end
+      end
+
+      @p.binding_stack = [binding]
+      m = Pry::CodeObject.lookup("o#princess_bubblegum", @p)
+      m.is_a?(Pry::Method).should == true
+      m.source.should =~ /mathematic!/
+    end
+
+    it 'should lookup class methods defined on classes accessed via local variable' do
+      o = Class.new do
+        def self.finn
+          "4 realzies"
+        end
+      end
+      @p.binding_stack = [binding]
+      m = Pry::CodeObject.lookup("o.finn", @p)
+      m.is_a?(Pry::Method).should == true
+      m.source.should =~ /4 realzies/
+    end
+
+    it 'should lookup the class of an object (when given a variable)' do
+      moddy = ClassyWassy.new
+      @p.binding_stack = [binding]
+      m = Pry::CodeObject.lookup("moddy", @p)
+      m.is_a?(Pry::WrappedModule).should == true
+      m.source.should =~ /piggy/
+    end
+
+    describe "inferring object from binding when lookup str is empty/nil" do
+      before do
+        @b1 = Pry.binding_for(ClassyWassy)
+        @b2 = Pry.binding_for(ClassyWassy.new)
+      end
+
+      describe "infer module objects" do
+        it 'should infer module object when binding self is a module' do
+          ["", nil].each do |v|
+            @p.binding_stack = [@b1]
+            m = Pry::CodeObject.lookup(v, @p)
+            m.is_a?(Pry::WrappedModule).should == true
+            m.name.should =~ /ClassyWassy/
+          end
+        end
+
+        it 'should infer module object when binding self is an instance' do
+          ["", nil].each do |v|
+            @p.binding_stack = [@b2]
+            m = Pry::CodeObject.lookup(v, @p)
+            m.is_a?(Pry::WrappedModule).should == true
+            m.name.should =~ /ClassyWassy/
+          end
+        end
+      end
+
+      describe "infer method objects" do
+        it 'should infer method object from binding when inside method context' do
+          b = ClassyWassy.new.piggy
+
+          ["", nil].each do |v|
+            @p.binding_stack = [b]
+            m = Pry::CodeObject.lookup(v, @p)
+            m.is_a?(Pry::Method).should == true
+            m.name.should =~ /piggy/
+          end
+        end
+      end
+    end
+  end
+
+  describe "lookups with :super" do
+    before do
+      class MyClassyWassy; end
+      class CuteSubclass < MyClassyWassy; end
+      @p = Pry.new
+      @p.binding_stack = [binding]
+    end
+
+    after do
+      Object.remove_const(:MyClassyWassy)
+      Object.remove_const(:CuteSubclass)
+    end
+
+    it 'should lookup original class with :super => 0' do
+      m = Pry::CodeObject.lookup("CuteSubclass", @p, :super => 0)
+      m.is_a?(Pry::WrappedModule).should == true
+      m.wrapped.should == CuteSubclass
+    end
+
+    it 'should lookup immediate super class with :super => 1' do
+      m = Pry::CodeObject.lookup("CuteSubclass", @p, :super => 1)
+      m.is_a?(Pry::WrappedModule).should == true
+      m.wrapped.should == MyClassyWassy
+    end
+
+    it 'should ignore :super parameter for commands' do
+      p = Pry.new
+      p.commands.command "jeremy-jones" do
+        "lobster"
+      end
+      p.binding_stack = [binding]
+      m = Pry::CodeObject.lookup("jeremy-jones", p, :super => 10)
+      m.source.should =~ /lobster/
+    end
+  end
+
+  describe "precedence" do
+    before do
+      class ClassyWassy
+        class Puff
+          def tiggy
+          end
+        end
+
+        def Puff
+        end
+
+        def piggy
+        end
+      end
+
+      Object.class_eval do
+        def ClassyWassy
+          :ducky
+        end
+      end
+
+      @p = Pry.new
+      @p.binding_stack = [binding]
+    end
+
+    after do
+      Object.remove_const(:ClassyWassy)
+      Object.remove_method(:ClassyWassy)
+    end
+
+    it 'should look up methods before classes (at top-level)' do
+      m = Pry::CodeObject.lookup("ClassyWassy", @p)
+      m.is_a?(Pry::Method).should == true
+      m.source.should =~ /ducky/
+    end
+
+    it 'should look up classes before methods when namespaced' do
+      m = Pry::CodeObject.lookup("ClassyWassy::Puff", @p)
+      m.is_a?(Pry::WrappedModule).should == true
+      m.source.should =~ /tiggy/
+    end
+
+    it 'should look up locals before methods' do
+      b = Pry.binding_for(ClassyWassy)
+      b.eval("piggy = Puff.new")
+      @p.binding_stack = [b]
+      o = Pry::CodeObject.lookup("piggy", @p)
+      o.is_a?(Pry::WrappedModule).should == true
+    end
+
+    # actually locals are never looked up (via co.default_lookup)  when they're classes, it
+    # just falls through to co.method_or_class
+    it 'should look up classes before locals' do
+      c = ClassyWassy
+      @p.binding_stack = [binding]
+      o = Pry::CodeObject.lookup("c", @p)
+      o.is_a?(Pry::WrappedModule).should == true
+      o.wrapped.should == ClassyWassy
+    end
+  end
+end

data/{test/test_code.rb → spec/code_spec.rb}

@@ -7,7 +7,7 @@ describe Pry::Code do
     end
 
     should 'read lines from Pry\'s line buffer' do
-      mock_pry(':hay_guys')
+      pry_eval ':hay_guys'
       Pry::Code.from_file('(pry)').grep(/:hay_guys/).length.should == 1
     end
 
@@ -23,11 +23,29 @@ describe Pry::Code do
       end
     end
 
+    should 'use the provided extension' do
+      temp_file('.c') do |f|
+        Pry::Code.from_file(f.path, :ruby).code_type.should == :ruby
+      end
+    end
+
     should 'raise an error if the file doesn\'t exist' do
       proc do
         Pry::Code.from_file('/knalkjsdnalsd/alkjdlkq')
       end.should.raise(MethodSource::SourceNotFoundError)
     end
+
+    should 'check for files relative to origin pwd' do
+      Dir.chdir('spec') do |f|
+        Pry::Code.from_file('spec/' + File.basename(__FILE__)).code_type.should == :ruby
+      end
+    end
+
+    should 'find files that are relative to the current working directory' do
+      Dir.chdir('spec') do |f|
+        Pry::Code.from_file(File.basename(__FILE__)).code_type.should == :ruby
+      end
+    end
   end
 
   describe '.from_method' do

data/{test/test_command_integration.rb → spec/command_integration_spec.rb}

@@ -1,5 +1,6 @@
 require 'helper'
 
+
 describe "commands" do
   before do
     @str_output = StringIO.new
@@ -12,6 +13,16 @@ describe "commands" do
 
     @self  = "Pad.self = self"
 
+    @command_tester = Pry::CommandSet.new do
+      command "command1", "command 1 test" do
+        output.puts "command1"
+      end
+
+      command "command2", "command 2 test" do |arg|
+        output.puts arg
+      end
+    end
+
     Pad.bong = "bong"
   end
 
@@ -46,17 +57,10 @@ describe "commands" do
         alias_command "test-alias", "test-command"
       end
 
-      redirect_pry_io(InputTester.new("test-command hello baby duck"), out1 = StringIO.new) do
-        Pry.start self, :commands => set
-      end
-
-      out1.string.should =~ /hello baby duck/
-
-      redirect_pry_io(InputTester.new("test-alias hello baby duck"), out2 = StringIO.new) do
-        Pry.start self, :commands => set
-      end
+      t = pry_tester(:commands => set)
 
-      out2.string.should == out1.string
+      t.process_command "test-alias hello baby duck"
+      t.last_output.should =~ /testing hello baby duck/
     end
 
     it 'should pass option arguments to original' do
@@ -66,17 +70,10 @@ describe "commands" do
       end
 
       obj = Class.new { @x = 10 }
-      redirect_pry_io(InputTester.new("ls -i"), out1 = StringIO.new) do
-        Pry.start obj, :commands => set
-      end
-
-      out1.string.should =~ /@x/
-
-      redirect_pry_io(InputTester.new("test-alias -i"), out2 = StringIO.new) do
-        Pry.start obj, :commands => set
-      end
+      t = pry_tester(obj, :commands => set)
 
-      out2.string.should == out1.string
+      t.process_command "test-alias -i"
+      t.last_output.should =~ /@x/
     end
 
     it 'should pass option arguments to original with additional parameters' do
@@ -86,17 +83,9 @@ describe "commands" do
       end
 
       obj = Class.new { @x = Class.new { define_method(:plymouth) {} } }
-      redirect_pry_io(InputTester.new("ls -M @x"), out1 = StringIO.new) do
-        Pry.start obj, :commands => set
-      end
-
-      out1.string.should =~ /plymouth/
-
-      redirect_pry_io(InputTester.new("test-alias @x"), out2 = StringIO.new) do
-        Pry.start obj, :commands => set
-      end
-
-      out2.string.should == out1.string
+      t = pry_tester(obj, :commands => set)
+      t.process_command "test-alias @x"
+      t.last_output.should =~ /plymouth/
     end
 
     it 'should be able to alias a regex command' do
@@ -107,11 +96,9 @@ describe "commands" do
         alias_command "test-alias", "duck"
       end
 
-      redirect_pry_io(InputTester.new("test-alias"), out1 = StringIO.new) do
-        Pry.start self, :commands => set
-      end
-
-      out1.string.should =~ /ducky/
+      t = pry_tester(:commands => set)
+      t.process_command "test-alias"
+      t.last_output.should =~ /ducky/
     end
 
     it 'should be able to make the alias a regex' do
@@ -138,6 +125,7 @@ describe "commands" do
           run "cd / "
         end
       end
+
       redirect_pry_io(InputTester.new("cd 1/2/3/4/5/6", @bs1, "test-run",
                                       @self, @bs2, "exit-all")) do
         Pry.start(@o, :commands => set)
@@ -242,10 +230,10 @@ describe "commands" do
 
   describe "Pry#run_command" do
     it 'should run a command in a specified context' do
-      b = Pry.binding_for(7)
+      b = Pry.binding_for('seven')
       p = Pry.new(:output => @str_output)
       p.run_command("ls -m", "", b)
-      p.output.string.should =~ /divmod/
+      p.output.string.should =~ /downcase/
     end
 
     it 'should run a command that modifies the passed in eval_string' do
@@ -258,7 +246,10 @@ describe "commands" do
     end
 
     it 'should run a command in the context of a session' do
-      mock_pry("@session_ivar = 10", "_pry_.run_command('ls')").should =~ /@session_ivar/
+      pry_tester.tap do |t|
+        t.eval "@session_ivar = 10", "_pry_.run_command('ls')"
+        t.last_output.should =~ /@session_ivar/
+      end
     end
   end
 
@@ -417,7 +408,7 @@ describe "commands" do
   it 'should create a command in a nested context and that command should be accessible from the parent' do
     x = "@x=nil\ncd 7\n_pry_.commands.instance_eval {\ncommand('bing') { |arg| run arg }\n}\ncd ..\nbing ls\nexit-all"
     redirect_pry_io(StringIO.new("@x=nil\ncd 7\n_pry_.commands.instance_eval {\ncommand('bing') { |arg| run arg }\n}\ncd ..\nbing ls\nexit-all"), @str_output) do
-      Pry.new.repl(0)
+      Pry.new.repl('0')
     end
 
     @str_output.string.should =~ /@x/
@@ -482,7 +473,6 @@ describe "commands" do
     @str_output.string.should =~ /6/
   end
 
-
   it 'a command (with :keep_retval => true) that replaces eval_string with a valid expression should overwrite the eval_string with the return value' do
     klass = Pry::CommandSet.new do
       command "hello", "", :keep_retval => true do
@@ -546,7 +536,9 @@ describe "commands" do
   end
 
   it 'should change description of a command using desc' do
-    klass = Pry::CommandSet.new do; import Pry::DefaultCommands::Help; end
+    klass = Pry::CommandSet.new do
+      import Pry::Commands
+    end
     orig = klass.commands["help"].description
     klass.instance_eval do
       desc "help", "blah"
@@ -626,9 +618,9 @@ describe "commands" do
 
   it 'should run a command with no parameter' do
     pry_tester = Pry.new
-    pry_tester.commands = CommandTester
+    pry_tester.commands = @command_tester
     pry_tester.input = InputTester.new("command1", "exit-all")
-    pry_tester.commands = CommandTester
+    pry_tester.commands = @command_tester
 
     pry_tester.output = @str_output
 
@@ -639,9 +631,9 @@ describe "commands" do
 
   it 'should run a command with one parameter' do
     pry_tester = Pry.new
-    pry_tester.commands = CommandTester
+    pry_tester.commands = @command_tester
     pry_tester.input = InputTester.new("command2 horsey", "exit-all")
-    pry_tester.commands = CommandTester
+    pry_tester.commands = @command_tester
 
     pry_tester.output = @str_output