pry 0.9.5-java → 0.9.6-java

data/test/test_default_commands/test_introspection.rb

@@ -1,6 +1,219 @@
 require 'helper'
 
 describe "Pry::DefaultCommands::Introspection" do
+
+  describe "edit" do
+    before do
+      @old_editor = Pry.config.editor
+      @file = nil; @line = nil; @contents = nil
+      Pry.config.editor = lambda do |file, line|
+        @file = file; @line = line; @contents = File.read(@file)
+        nil
+      end
+    end
+    after do
+      Pry.config.editor = @old_editor
+    end
+
+    describe "with FILE" do
+      it "should invoke Pry.config.editor with absolutified filenames" do
+        mock_pry("edit foo.rb")
+        @file.should == File.expand_path("foo.rb")
+        mock_pry("edit /tmp/bar.rb")
+        @file.should == "/tmp/bar.rb"
+      end
+
+      it "should guess the line number from a colon" do
+        mock_pry("edit /tmp/foo.rb:10")
+        @line.should == 10
+      end
+
+      it "should use the line number from -l" do
+        mock_pry("edit -l 10 /tmp/foo.rb")
+        @line.should == 10
+      end
+
+      it "should not delete the file!" do
+        mock_pry("edit Rakefile")
+        File.exist?(@file).should == true
+      end
+
+      describe do
+        before do
+          @rand = rand
+          Pry.config.editor = lambda { |file, line|
+            File.open(file, 'w') { |f| f << "$rand = #{@rand.inspect}" }
+            nil
+          }
+        end
+
+        it "should reload the file if it is a ruby file" do
+          tf = Tempfile.new(["tmp", ".rb"])
+          path = tf.path
+
+          mock_pry("edit #{path}", "$rand").should =~ /#{@rand}/
+
+          tf.close
+        end
+
+        it "should not reload the file if it is not a ruby file" do
+          tf = Tempfile.new(["tmp", ".py"])
+          path = tf.path
+
+          mock_pry("edit #{path}", "$rand").should.not =~ /#{@rand}/
+
+          tf.close
+        end
+
+        it "should not reload a ruby file if -n is given" do
+          tf = Tempfile.new(["tmp", ".rb"])
+          path = tf.path
+
+          mock_pry("edit -n #{path}", "$rand").should.not =~ /#{@rand}/
+
+          tf.close
+        end
+
+        it "should reload a non-ruby file if -r is given" do
+          tf = Tempfile.new(["tmp", ".pryrc"])
+          path = tf.path
+
+          mock_pry("edit -r #{path}", "$rand").should =~ /#{@rand}/
+
+          tf.close
+        end
+      end
+    end
+
+    describe "with --ex" do
+      before do
+        @tf = Tempfile.new(["tmp", ".rb"])
+        @path = @tf.path
+        @tf << "1\n2\nraise RuntimeError"
+        @tf.flush
+      end
+      after do
+        @tf.close
+        File.unlink("#{@path}c") if File.exists?("#{@path}c") #rbx
+      end
+      it "should open the correct file" do
+        mock_pry("require #{@path.inspect}", "edit --ex")
+
+        @file.should == @path
+        @line.should == 3
+      end
+
+      it "should reload the file" do
+        Pry.config.editor = lambda {|file, line|
+          File.open(file, 'w'){|f| f << "FOO = 'BAR'" }
+          nil
+        }
+
+        mock_pry("require #{@path.inspect}", "edit --ex", "FOO").should =~ /BAR/
+      end
+
+      it "should not reload the file if -n is passed" do
+        Pry.config.editor = lambda {|file, line|
+          File.open(file, 'w'){|f| f << "FOO2 = 'BAZ'" }
+          nil
+        }
+
+        mock_pry("require #{@path.inspect}", "edit -n --ex", "FOO2").should.not =~ /BAZ/
+      end
+    end
+
+    describe "with --ex NUM" do
+      before do
+        Pry.config.editor = proc do |file, line|
+          @__ex_file__ = file
+          @__ex_line__ = line
+          nil
+        end
+      end
+
+      it 'should start editor on first level of backtrace when --ex used with no argument ' do
+        pry_instance = Pry.new(:input => StringIO.new("edit -n --ex"), :output => StringIO.new)
+        pry_instance.last_exception = MockPryException.new("a:1", "b:2", "c:3")
+        pry_instance.rep(self)
+        @__ex_file__.should == "a"
+        @__ex_line__.should == 1
+      end
+
+      it 'should start editor on first level of backtrace when --ex 0 used ' do
+        pry_instance = Pry.new(:input => StringIO.new("edit -n --ex 0"), :output => StringIO.new)
+        pry_instance.last_exception = MockPryException.new("a:1", "b:2", "c:3")
+        pry_instance.rep(self)
+        @__ex_file__.should == "a"
+        @__ex_line__.should == 1
+      end
+
+      it 'should start editor on second level of backtrace when --ex 1 used' do
+        pry_instance = Pry.new(:input => StringIO.new("edit -n --ex 1"), :output => StringIO.new)
+        pry_instance.last_exception = MockPryException.new("a:1", "b:2", "c:3")
+        pry_instance.rep(self)
+        @__ex_file__.should == "b"
+        @__ex_line__.should == 2
+      end
+
+      it 'should start editor on third level of backtrace when --ex 2 used' do
+        pry_instance = Pry.new(:input => StringIO.new("edit -n --ex 2"), :output => StringIO.new)
+        pry_instance.last_exception = MockPryException.new("a:1", "b:2", "c:3")
+        pry_instance.rep(self)
+        @__ex_file__.should == "c"
+        @__ex_line__.should == 3
+      end
+
+      it 'should display error message when backtrace level is out of bounds (using --ex 4)' do
+        pry_instance = Pry.new(:input => StringIO.new("edit -n --ex 4"), :output => str_output = StringIO.new)
+        pry_instance.last_exception = MockPryException.new("a:1", "b:2", "c:3")
+        pry_instance.rep(self)
+        str_output.string.should =~ /Exception has no associated file/
+      end
+    end
+
+    describe "without FILE" do
+      it "should edit the current expression if it's incomplete" do
+        mock_pry("def a", "edit")
+        @contents.should == "def a\n"
+      end
+
+      it "should edit the previous expression if the current is empty" do
+        mock_pry("def a; 2; end", "edit")
+        @contents.should == "def a; 2; end\n"
+      end
+
+      it "should use a blank file if -t is specified" do
+        mock_pry("def a; 5; end", "edit -t")
+        @contents.should == "\n"
+      end
+
+      it "should use a blank file if -t is specified even half-way through an expression" do
+        mock_pry("def a;", "edit -t")
+        @contents.should == "\n"
+      end
+
+      it "should position the cursor at the end of the expression" do
+        mock_pry("def a; 2;"," end", "edit")
+        @line.should == 2
+      end
+
+      it "should evaluate the expression" do
+        Pry.config.editor = lambda {|file, line|
+          File.open(file, 'w'){|f| f << "'FOO'\n" }
+          nil
+        }
+        mock_pry("edit").should =~ /FOO/
+      end
+      it "should not evaluate the expression with -n" do
+        Pry.config.editor = lambda {|file, line|
+          File.open(file, 'w'){|f| f << "'FOO'\n" }
+          nil
+        }
+        mock_pry("edit -n").should.not =~ /FOO/
+      end
+    end
+  end
+
   describe "show-method" do
     it 'should output a method\'s source' do
       str_output = StringIO.new
@@ -10,7 +223,7 @@ 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
@@ -114,6 +327,126 @@ describe "Pry::DefaultCommands::Introspection" do
     end
   end
 
+  describe "edit-method" do
+    describe "on a method defined in a file" do
+      before do
+        @tempfile = Tempfile.new(['tmp', '*.rb'])
+        @tempfile.puts <<-EOS
+          module A
+            def a
+              :yup
+            end
+          end
+
+          class X
+            include A
+
+            def self.x
+              :double_yup
+            end
+
+            def x
+              :nope
+            end
+          end
+        EOS
+        @tempfile.flush
+        load @tempfile.path
+      end
+
+      after do
+        @tempfile.close
+      end
+
+      describe 'without -p' do
+        before do
+          @old_editor = Pry.config.editor
+          @file, @line, @contents = nil, nil, nil
+          Pry.config.editor = lambda do |file, line|
+            @file = file; @line = line
+            nil
+          end
+        end
+        after do
+          Pry.config.editor = @old_editor
+        end
+
+        it "should correctly find a class method" do
+          mock_pry("edit-method X.x")
+          @file.should == @tempfile.path
+          @line.should == 10
+        end
+
+        it "should correctly find an instance method" do
+          mock_pry("edit-method X#x")
+          @file.should == @tempfile.path
+          @line.should == 14
+        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
+        end
+
+        it "should correctly find a method from a module" do
+          mock_pry("edit-method X#a")
+          @file.should == @tempfile.path
+          @line.should == 2
+        end
+      end
+
+      describe 'with -p' do
+        before do
+          @old_editor = Pry.config.editor
+          Pry.config.editor = lambda do |file, line|
+            lines = File.read(file).lines.to_a
+            lines[1] = ":maybe\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 successfully replace a class method" do
+          mock_pry("edit-method -p X.x")
+
+          class << X
+            X.method(:x).owner.should == self
+          end
+          X.method(:x).receiver.should == X
+          X.x.should == :maybe
+        end
+
+        it "should successfully replace an instance method" do
+          mock_pry("edit-method -p X#x")
+
+          X.instance_method(:x).owner.should == X
+          X.new.x.should == :maybe
+        end
+
+        it "should successfully replace a method on an instance" do
+          mock_pry("instance = X.new", "edit-method -p instance.x")
+
+          instance = X.new
+          instance.method(:x).owner.should == X
+          instance.x.should == :maybe
+        end
+
+        it "should successfully replace a method from a module" do
+          mock_pry("edit-method -p X#a")
+
+          X.instance_method(:a).owner.should == A
+          X.new.a.should == :maybe
+        end
+      end
+    end
+  end
+
   # show-command only works in implementations that support Proc#source_location
   if Proc.method_defined?(:source_location)
     describe "show-command" do

data/test/test_default_commands/test_shell.rb

@@ -3,16 +3,111 @@ require 'helper'
 describe "Pry::DefaultCommands::Shell" do
   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/
+      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
-    if !rbx?
-      it 'cat --ex should give warning when exception is raised in repl' do
-        mock_pry("this raises error", "cat --ex").should =~ /Cannot cat exceptions raised in REPL/
+    describe "with --ex" do
+      if !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
+
+        it 'cat --ex should correctly display code that generated exception' do
+          mock_pry("broken_method", "cat --ex").should =~ /this method is broken/
+        end
       end
+    end
+
+    describe "with --ex N" do
+      it 'should cat first level of backtrace when --ex used with no argument ' do
+        pry_instance = Pry.new(:input => StringIO.new("cat --ex"), :output => str_output = StringIO.new)
+
+        temp_file do |f|
+          f << "bt number 1"
+          f.flush
+          pry_instance.last_exception = MockPryException.new("#{f.path}:1", "x", "x")
+          pry_instance.rep(self)
+        end
+
+        str_output.string.should =~ /bt number 1/
+      end
+
+      it 'should cat first level of backtrace when --ex 0 used ' do
+        pry_instance = Pry.new(:input => StringIO.new("cat --ex 0"), :output => str_output = StringIO.new)
+
+        temp_file do |f|
+          f << "bt number 1"
+          f.flush
+          pry_instance.last_exception = MockPryException.new("#{f.path}:1", "x", "x")
+          pry_instance.rep(self)
+        end
+
+        str_output.string.should =~ /bt number 1/
+      end
+
+      it 'should cat second level of backtrace when --ex 1 used ' do
+        pry_instance = Pry.new(:input => StringIO.new("cat --ex 1"), :output => str_output = StringIO.new)
+
+        temp_file do |f|
+          f << "bt number 2"
+          f.flush
+          pry_instance.last_exception = MockPryException.new("x", "#{f.path}:1", "x")
+          pry_instance.rep(self)
+        end
 
-      it 'cat --ex should correctly display code that generated exception' do
-        mock_pry("broken_method", "cat --ex").should =~ /this method is broken/
+        str_output.string.should =~ /bt number 2/
       end
+
+      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.rep(self)
+        end
+
+        str_output.string.should =~ /bt number 3/
+      end
+
+      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.rep(self)
+        str_output.string.should =~ /No Exception or Exception has no associated file/
+      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.last << "bt number #{i}"
+          temp_files.last.flush
+        end
+
+        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" })
+
+        3.times do |i|
+          pry_instance.rep(self)
+          str_output.string.should =~ /bt number #{i}/
+        end
+
+        str_output.reopen
+        pry_instance.rep(self)
+        str_output.string.should =~ /bt number 0/
+
+        temp_files.each(&:close)
+      end
+
     end
   end
 end