pry 0.10.2-i386-mingw32 → 1.0.0.pre1-i386-mingw32

data/spec/pryrc_spec.rb

@@ -0,0 +1,97 @@
+require 'helper'
+
+describe Pry do
+  describe 'loading rc files' do
+    before do
+      Pry::HOME_RC_FILE.replace "spec/fixtures/testrc"
+      Pry::LOCAL_RC_FILE.replace "spec/fixtures/testrc/../testrc"
+      Pry.instance_variable_set(:@initial_session, true)
+      Pry.config.should_load_rc = true
+      Pry.config.should_load_local_rc = true
+    end
+
+    after do
+      Pry::HOME_RC_FILE.replace "~/.pryrc"
+      Pry::LOCAL_RC_FILE.replace "./.pryrc"
+      Pry.config.should_load_rc = false
+      Object.remove_const(:TEST_RC) if defined?(TEST_RC)
+    end
+
+    it "should never run the rc file twice" do
+      Pry.start(self, :input => StringIO.new("exit-all\n"), :output => StringIO.new)
+      TEST_RC.should == [0]
+
+      Pry.start(self, :input => StringIO.new("exit-all\n"), :output => StringIO.new)
+      TEST_RC.should == [0]
+    end
+
+    # Resolving symlinks doesn't work on jruby 1.9 [jruby issue #538]
+    unless Pry::Helpers::BaseHelpers.jruby_19?
+      it "should not load the rc file twice if it's symlinked differently" do
+        Pry::HOME_RC_FILE.replace "spec/fixtures/testrc"
+        Pry::LOCAL_RC_FILE.replace "spec/fixtures/testlinkrc"
+
+        Pry.start(self, :input => StringIO.new("exit-all\n"), :output => StringIO.new)
+
+        TEST_RC.should == [0]
+      end
+    end
+
+    it "should not load the pryrc if it cannot expand ENV[HOME]" do
+      old_home = ENV['HOME']
+      ENV['HOME'] = nil
+      Pry.config.should_load_rc = true
+      lambda { Pry.start(self, :input => StringIO.new("exit-all\n"), :output => StringIO.new) }.should.not.raise
+
+      ENV['HOME'] = old_home
+    end
+
+    it "should not run the rc file at all if Pry.config.should_load_rc is false" do
+      Pry.config.should_load_rc = false
+      Pry.config.should_load_local_rc = false
+      Pry.start(self, :input => StringIO.new("exit-all\n"), :output => StringIO.new)
+      Object.const_defined?(:TEST_RC).should == false
+    end
+
+    describe "that raise exceptions" do
+      before do
+        Pry::HOME_RC_FILE = "spec/fixtures/testrcbad"
+        Pry.config.should_load_local_rc = false
+
+        putsed = nil
+
+        # YUCK! horrible hack to get round the fact that output is not configured
+        # at the point this message is printed.
+        (class << Pry; self; end).send(:define_method, :puts) { |str|
+          putsed = str
+        }
+
+        @doing_it = lambda{
+          Pry.start(self, :input => StringIO.new("Object::TEST_AFTER_RAISE=1\nexit-all\n"), :output => StringIO.new)
+          putsed
+        }
+      end
+
+      after do
+        Object.remove_const(:TEST_BEFORE_RAISE)
+        Object.remove_const(:TEST_AFTER_RAISE)
+        (class << Pry; undef_method :puts; end)
+      end
+
+      it "should not raise exceptions" do
+        @doing_it.should.not.raise
+      end
+
+      it "should continue to run pry" do
+        @doing_it[]
+        Object.const_defined?(:TEST_BEFORE_RAISE).should == true
+        Object.const_defined?(:TEST_AFTER_RAISE).should == true
+      end
+
+      it "should output an error" do
+        @doing_it.call.split("\n").first.should =~
+          %r{Error loading .*spec/fixtures/testrcbad: messin with ya}
+      end
+    end
+  end
+end

data/spec/run_command_spec.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+describe "Pry.run_command" do
+  before do
+    o = Object.new
+    def o.drum
+      "roken is dodelijk"
+    end
+    @context = Pry.binding_for(o)
+  end
+
+  it 'performs a simple ls' do
+    @context.eval("hokey_pokey = 10")
+    Pry.run_command "ls", :context => @context, :output => out = StringIO.new
+    out.string.should =~ /hokey_pokey/
+  end
+
+  if !PryTestHelpers.mri18_and_no_real_source_location?
+    # This is a regression test as 0.9.11 broke this behaviour
+    it 'can perform a show-source' do
+      Pry.run_command "show-source drum", :context => @context, :output => out = StringIO.new
+      out.string.should =~ /roken is dodelijk/
+    end
+  end
+end

data/spec/sticky_locals_spec.rb

@@ -0,0 +1,147 @@
+require 'helper'
+
+describe "Sticky locals (_file_ and friends)" do
+  it 'locals should all exist upon initialization' do
+    proc {
+      pry_eval '_file_', '_dir_', '_ex_', '_pry_', '_'
+    }.should.not.raise(NameError)
+  end
+
+  it 'locals should still exist after cd-ing into a new context' do
+    proc {
+      pry_eval 'cd 0', '_file_', '_dir_', '_ex_', '_pry_', '_'
+    }.should.not.raise(NameError)
+  end
+
+  it 'locals should keep value after cd-ing (_pry_)' do
+    pry_tester.tap do |t|
+      pry = t.eval '_pry_'
+      t.eval 'cd 0'
+      t.eval('_pry_').should == pry
+    end
+  end
+
+  # Using mock_pry here until we figure out exception handling
+  it 'locals should keep value after cd-ing (_ex_)' do
+    mock_pry("error blah;", "$x = _ex_;", "cd 0", "_ex_ == $x").should =~ /true/
+  end
+
+  it 'locals should keep value after cd-ing (_file_ and _dir_)' do
+    Pry.commands.command "file-and-dir-test" do
+      set_file_and_dir_locals("/blah/ostrich.rb")
+    end
+
+    pry_eval('file-and-dir-test', 'cd 0', '_file_').
+      should =~ /\/blah\/ostrich\.rb/
+
+    pry_eval('file-and-dir-test', 'cd 0', '_dir_').
+      should =~ /\/blah/
+
+    Pry.commands.delete "file-and-dir-test"
+  end
+
+  describe "User defined sticky locals" do
+    describe "setting as Pry.config option" do
+      it 'should define a new sticky local for the session (normal value)' do
+        Pry.config.extra_sticky_locals[:test_local] = :john
+
+        o = Object.new
+        redirect_pry_io(InputTester.new("@value = test_local",
+                                        "exit-all")) do
+          Pry.start(o)
+        end
+
+        o.instance_variable_get(:@value).should == :john
+        Pry.config.extra_sticky_locals = {}
+      end
+
+      it 'should define a new sticky local for the session (proc)' do
+        Pry.config.extra_sticky_locals[:test_local] = proc { :john }
+
+        o = Object.new
+        redirect_pry_io(InputTester.new("@value = test_local",
+                                        "exit-all")) do
+          Pry.start(o)
+        end
+
+        o.instance_variable_get(:@value).should == :john
+        Pry.config.extra_sticky_locals = {}
+      end
+
+    end
+
+    describe "passing in as hash option when creating pry instance" do
+      it 'should define a new sticky local for the session (normal value)' do
+        o = Object.new
+        redirect_pry_io(InputTester.new("@value = test_local",
+                                        "exit-all")) do
+          Pry.start(o, :extra_sticky_locals => { :test_local => :john } )
+        end
+
+        o.instance_variable_get(:@value).should == :john
+      end
+
+      it 'should define multiple sticky locals' do
+        o = Object.new
+        redirect_pry_io(InputTester.new("@value1 = test_local1",
+                                        "@value2 = test_local2",
+                                        "exit-all")) do
+          Pry.start(o, :extra_sticky_locals => { :test_local1 => :john ,
+                      :test_local2 => :carl} )
+        end
+
+        o.instance_variable_get(:@value1).should == :john
+        o.instance_variable_get(:@value2).should == :carl
+      end
+
+
+      it 'should define a new sticky local for the session (as Proc)' do
+        o = Object.new
+        redirect_pry_io(InputTester.new("@value = test_local",
+                                        "exit-all")) do
+          Pry.start(o, :extra_sticky_locals => { :test_local => proc { :john }} )
+        end
+
+        o.instance_variable_get(:@value).should == :john
+      end
+    end
+
+    describe "hash option value should override config value" do
+      it 'should define a new sticky local for the session (normal value)' do
+        Pry.config.extra_sticky_locals[:test_local] = :john
+
+        o = Object.new
+        redirect_pry_io(InputTester.new("@value = test_local",
+                                        "exit-all")) do
+          Pry.start(o, :extra_sticky_locals => { :test_local => :carl })
+        end
+
+        o.instance_variable_get(:@value).should == :carl
+        Pry.config.extra_sticky_locals = {}
+      end
+    end
+
+    it 'should create a new sticky local' do
+      t = pry_tester
+      t.eval "_pry_.add_sticky_local(:test_local){ :test_value }"
+      t.eval("test_local").should == :test_value
+    end
+
+    it 'should still exist after cd-ing into new binding' do
+      t = pry_tester
+      t.eval "_pry_.add_sticky_local(:test_local){ :test_value }"
+      t.eval "cd Object.new"
+      t.eval("test_local").should == :test_value
+    end
+
+    it 'should provide different values for successive block invocations' do
+      pry = Pry.new
+      pry.push_binding binding
+      pry.add_sticky_local(:test_local) { rand }
+      value1 = pry.evaluate_ruby 'test_local'
+      value2 = pry.evaluate_ruby 'test_local'
+      value1.should.not == value2
+    end
+  end
+
+end

data/spec/syntax_checking_spec.rb

@@ -0,0 +1,81 @@
+require 'helper'
+
+describe Pry do
+  before do
+    @str_output = StringIO.new
+  end
+
+  [
+    ["p = '", "'"],
+    ["def", "a", "(); end"],
+    ["p = <<FOO", "lots", "and", "lots of", "foo", "FOO"],
+    ["[", ":lets,", "'list',", "[/nested/", "], things ]"],
+    ["abc =~ /hello", "/"],
+    ["issue = %W/", "343/"],
+    ["pouts(<<HI, 'foo", "bar", "HI", "baz')"],
+  ].each do |foo|
+    it "should not raise an error on broken lines: #{foo.join("\\n")}" do
+      redirect_pry_io(InputTester.new(*foo), @str_output) do
+        Pry.start
+      end
+
+      @str_output.string.should.not =~ /SyntaxError/
+    end
+  end
+
+  [
+    ["end"],
+    ["puts )("],
+    ["1 1"],
+    ["puts :"]
+  ] + (Pry::Helpers::BaseHelpers.rbx? ? [] : [
+    ["def", "method(1"], # in this case the syntax error is "expecting ')'".
+    ["o = Object.new.tap{ def o.render;","'MEH'", "}"] # in this case the syntax error is "expecting keyword_end".
+  ]).compact.each do |foo|
+    it "should raise an error on invalid syntax like #{foo.inspect}" do
+      redirect_pry_io(InputTester.new(*foo), @str_output) do
+        Pry.start
+      end
+
+      @str_output.string.should =~ /SyntaxError/
+    end
+  end
+
+  it "should not intefere with syntax errors explicitly raised" do
+    redirect_pry_io(InputTester.new(%q{raise SyntaxError, "unexpected $end"}), @str_output) do
+      Pry.start
+    end
+
+    @str_output.string.should =~ /SyntaxError/
+  end
+
+  it "should allow trailing , to continue the line" do
+    pry = Pry.new
+    Pry::Code.complete_expression?("puts 1, 2,").should == false
+  end
+
+  it "should complete an expression that contains a line ending with a ," do
+    pry = Pry.new
+    Pry::Code.complete_expression?("puts 1, 2,\n3").should == true
+  end
+
+  it "should not suppress the error output if the line ends in ;" do
+    mock_pry("raise RuntimeError, 'foo';").should =~ /RuntimeError/
+  end
+
+  it "should not clobber _ex_ on a SyntaxError in the repl" do
+    mock_pry("raise RuntimeError, 'foo'", "puts foo)", "_ex_.is_a?(RuntimeError)").should =~ /^RuntimeError.*\nSyntaxError.*\n=> true/m
+  end
+
+  it "should allow whitespace delimeted strings" do
+    mock_pry('"%s" %% foo ').should =~ /"foo"/
+  end
+
+  it "should allow newline delimeted strings" do
+    mock_pry('"%s" %%','foo').should =~ /"foo"/
+  end
+
+  it "should allow whitespace delimeted strings ending on the first char of a line" do
+    mock_pry('"%s" %% ', ' #done!').should =~ /"\\n"/
+  end
+end

data/spec/wrapped_module_spec.rb

@@ -0,0 +1,261 @@
+require 'helper'
+
+describe Pry::WrappedModule do
+
+  describe "#initialize" do
+    it "should raise an exception when a non-module is passed" do
+      lambda{ Pry::WrappedModule.new(nil) }.should.raise ArgumentError
+    end
+  end
+
+  describe "candidates" do
+    before do
+      class Host
+        %w(spec/fixtures/candidate_helper1.rb
+           spec/fixtures/candidate_helper2.rb).each do |file|
+          binding.eval File.read(file), file, 1
+        end
+
+        # rank 2
+        class CandidateTest
+          def test6
+          end
+        end
+
+        class ForeverAlone
+          class DoublyNested
+            # nested docs
+            class TriplyNested
+              def nested_method
+              end
+            end
+          end
+        end
+      end
+    end
+
+    describe "number_of_candidates" do
+      it 'should return the correct number of candidates' do
+        Pry::WrappedModule(Host::CandidateTest).number_of_candidates.should == 3
+      end
+
+      it 'should return 0 candidates for a class with no methods and no other definitions' do
+        Pry::WrappedModule(Host::ForeverAlone).number_of_candidates.should == 0
+      end
+    end
+
+    describe "ordering of candidates" do
+      it 'should return class with largest number of methods as primary candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(0).file.should =~ /helper1/
+      end
+
+      it 'should return class with second largest number of methods as second ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(1).file.should =~ /helper2/
+      end
+
+      it 'should return class with third largest number of methods as third ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(2).file.should =~ /#{__FILE__}/
+      end
+
+      it 'should raise when trying to access non-existent candidate' do
+        lambda { Pry::WrappedModule(Host::CandidateTest).candidate(3) }.should.raise Pry::CommandError
+      end
+    end
+
+    describe "source_location" do
+      it 'should return primary candidates source_location by default' do
+        wm = Pry::WrappedModule(Host::CandidateTest)
+        wm.source_location.should == wm.candidate(0).source_location
+      end
+
+      it 'should return nil if no source_location can be found' do
+        Pry::WrappedModule(Host::ForeverAlone).source_location.should == nil
+      end
+    end
+
+    describe "source" do
+      it 'should return primary candidates source by default' do
+        wm = Pry::WrappedModule(Host::CandidateTest)
+        wm.source.should == wm.candidate(0).source
+      end
+
+      it 'should return source for highest ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(0).source.should =~ /test1/
+      end
+
+      it 'should return source for second ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(1).source.should =~ /test4/
+      end
+
+      it 'should return source for third ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(2).source.should =~ /test6/
+      end
+
+      it 'should return source for deeply nested class' do
+        Pry::WrappedModule(Host::ForeverAlone::DoublyNested::TriplyNested).source.should =~ /nested_method/
+        Pry::WrappedModule(Host::ForeverAlone::DoublyNested::TriplyNested).source.lines.count.should == 4
+      end
+    end
+
+    describe "doc" do
+      it 'should return primary candidates doc by default' do
+        wm = Pry::WrappedModule(Host::CandidateTest)
+        wm.doc.should == wm.candidate(0).doc
+      end
+
+      it 'should return doc for highest ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(0).doc.should =~ /rank 0/
+      end
+
+      it 'should return doc for second ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(1).doc.should =~ /rank 1/
+      end
+
+      it 'should return doc for third ranked candidate' do
+        Pry::WrappedModule(Host::CandidateTest).candidate(2).doc.should =~ /rank 2/
+      end
+
+      it 'should return docs for deeply nested class' do
+        Pry::WrappedModule(Host::ForeverAlone::DoublyNested::TriplyNested).doc.should =~ /nested docs/
+      end
+    end
+
+    after do
+      Object.remove_const(:Host)
+    end
+  end
+
+  describe ".method_prefix" do
+    before do
+      Foo = Class.new
+      @foo = Foo.new
+    end
+
+    after do
+      Object.remove_const(:Foo)
+    end
+
+    it "should return Foo# for normal classes" do
+      Pry::WrappedModule.new(Foo).method_prefix.should == "Foo#"
+    end
+
+    it "should return Bar# for modules" do
+      Pry::WrappedModule.new(Kernel).method_prefix.should == "Kernel#"
+    end
+
+    it "should return Foo. for singleton classes of classes" do
+      Pry::WrappedModule.new(class << Foo; self; end).method_prefix.should == "Foo."
+    end
+
+    describe "of singleton classes of objects" do
+      Pry::WrappedModule.new(class << @foo; self; end).method_prefix.should == "self."
+    end
+
+    describe "of anonymous classes should not be empty" do
+      Pry::WrappedModule.new(Class.new).method_prefix.should =~ /#<Class:.*>#/
+    end
+
+    describe "of singleton classes of anonymous classes should not be empty" do
+      Pry::WrappedModule.new(class << Class.new; self; end).method_prefix.should =~ /#<Class:.*>./
+    end
+  end
+
+  describe ".singleton_class?" do
+    it "should be true for singleton classes" do
+      Pry::WrappedModule.new(class << ""; self; end).singleton_class?.should == true
+    end
+
+    it "should be false for normal classes" do
+      Pry::WrappedModule.new(Class.new).singleton_class?.should == false
+    end
+
+    it "should be false for modules" do
+      Pry::WrappedModule.new(Module.new).singleton_class?.should == false
+    end
+  end
+
+  describe ".singleton_instance" do
+    it "should raise an exception when called on a non-singleton-class" do
+      lambda{ Pry::WrappedModule.new(Class).singleton_instance }.should.raise ArgumentError
+    end
+
+    it "should return the attached object" do
+      Pry::WrappedModule.new(class << "hi"; self; end).singleton_instance.should == "hi"
+      Pry::WrappedModule.new(class << Object; self; end).singleton_instance.should.equal?(Object)
+    end
+  end
+
+  describe ".super" do
+    describe "receiver is a class" do
+      before do
+        @a = Class.new
+        @m = Module.new
+        @b = Class.new(@a)
+        @b.send(:include, @m)
+        @c = Class.new(@b)
+      end
+
+      it 'should return superclass for a wrapped class'  do
+        Pry::WrappedModule(@c).super.wrapped.should == @b
+      end
+
+      it 'should return nth superclass for a wrapped class'  do
+        d = Class.new(@c)
+        Pry::WrappedModule(d).super(2).wrapped.should == @b
+      end
+
+      it 'should ignore modules when retrieving nth superclass'  do
+        Pry::WrappedModule(@c).super(2).wrapped.should == @a
+      end
+
+      it 'should return nil when no nth superclass exists' do
+        Pry::WrappedModule(@c).super(10).should == nil
+      end
+
+      it 'should return self when .super(0) is used' do
+        c = Pry::WrappedModule(@c)
+        c.super(0).should == c
+      end
+    end
+
+    describe "receiver is a module" do
+      before do
+        @m1 = Module.new
+        @m2 = Module.new.tap { |v| v.send(:include, @m1) }
+        @m3 = Module.new.tap { |v| v.send(:include, @m2) }
+      end
+
+      it 'should not ignore modules when retrieving supers' do
+        Pry::WrappedModule(@m3).super.wrapped.should == @m2
+      end
+
+      it 'should retrieve nth super' do
+        Pry::WrappedModule(@m3).super(2).wrapped.should == @m1
+      end
+
+      it 'should return self when .super(0) is used' do
+        m = Pry::WrappedModule(@m1)
+        m.super(0).should == m
+      end
+    end
+  end
+
+  describe ".from_str" do
+    it 'should lookup a constant' do
+      m = Pry::WrappedModule.from_str("Host::CandidateTest", binding)
+      m.wrapped.should == Host::CandidateTest
+    end
+
+    it 'should lookup a local' do
+      local = Host::CandidateTest
+      m = Pry::WrappedModule.from_str("local", binding)
+      m.wrapped.should == Host::CandidateTest
+    end
+
+    it 'should lookup an ivar' do
+      @ivar = Host::CandidateTest
+      m = Pry::WrappedModule.from_str("@ivar", binding)
+      m.wrapped.should == Host::CandidateTest
+    end
+  end
+end