pry 0.9.12.6 → 0.10.0.pre2

data/spec/run_command_spec.rb

@@ -1,25 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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
-      o = Object.new
-      pi = Pry.new
-      pi.add_sticky_local(:test_local) { :test_value }
-      pi.input, pi.output = InputTester.new("@value = test_local", "exit-all"), StringIO.new
-      pi.repl(o)
-
-      o.instance_variable_get(:@value).should == :test_value
-    end
-
-    it 'should still exist after cd-ing into new binding' do
-      o = Object.new
-      o2 = Object.new
-      o.instance_variable_set(:@o2, o2)
-      pi = Pry.new
-      pi.add_sticky_local(:test_local) { :test_value }
-      pi.input = InputTester.new("cd @o2\n",
-                                 "@value = test_local", "exit-all")
-      pi.output = StringIO.new
-      pi.repl(o)
-
-      o2.instance_variable_get(:@value).should == :test_value
-    end
-
-    it 'should provide different values for successive block invocations' do
-      pry = Pry.new
-      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

@@ -1,81 +0,0 @@
-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

@@ -1,261 +0,0 @@
-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