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

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/spec/code_spec.rb

@@ -0,0 +1,219 @@
+require 'helper'
+
+describe Pry::Code do
+  describe '.from_file' do
+    should 'read lines from a file on disk' do
+      Pry::Code.from_file('lib/pry.rb').length.should > 0
+    end
+
+    should 'read lines from Pry\'s line buffer' do
+      pry_eval ':hay_guys'
+      Pry::Code.from_file('(pry)').grep(/:hay_guys/).length.should == 1
+    end
+
+    should 'default to Ruby' do
+      temp_file('') do |f|
+        Pry::Code.from_file(f.path).code_type.should == :ruby
+      end
+    end
+
+    should 'check the extension' do
+      temp_file('.c') do |f|
+        Pry::Code.from_file(f.path).code_type.should == :c
+      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
+    should 'read lines from a method\'s definition' do
+      m = Pry::Method.from_obj(Pry, :load_history)
+      Pry::Code.from_method(m).length.should > 0
+    end
+  end
+
+  describe '#initialize' do
+    before do
+      @str = Pry::Helpers::CommandHelpers.unindent <<-CODE
+        def hay
+          :guys
+        end
+      CODE
+
+      @array = ['def hay', '  :guys', 'end']
+    end
+
+    should 'break a string into lines' do
+      Pry::Code.new(@str).length.should == 3
+    end
+
+    should 'accept an array' do
+      Pry::Code.new(@array).length.should == 3
+    end
+
+    it 'an array or string should produce an equivalent object' do
+      Pry::Code.new(@str).should == Pry::Code.new(@array)
+    end
+  end
+
+  describe 'filters and formatters' do
+    before do
+      @code = Pry::Code(Pry::Helpers::CommandHelpers.unindent <<-STR)
+        class MyProgram
+          def self.main
+            puts 'Hello, world!'
+          end
+        end
+      STR
+    end
+
+    describe 'filters' do
+      describe '#between' do
+        should 'work with an inclusive range' do
+          @code = @code.between(1..3)
+          @code.length.should == 3
+          @code.should =~ /\Aclass MyProgram/
+          @code.should =~ /world!'\Z/
+        end
+
+        should 'default to an inclusive range' do
+          @code = @code.between(3, 5)
+          @code.length.should == 3
+        end
+
+        should 'work with an exclusive range' do
+          @code = @code.between(2...4)
+          @code.length.should == 2
+          @code.should =~ /\A  def self/
+          @code.should =~ /world!'\Z/
+        end
+
+        should 'use real line numbers for positive indices' do
+          @code = @code.after(3, 3)
+          @code = @code.between(4, 4)
+          @code.length.should == 1
+          @code.should =~ /\A  end\Z/
+        end
+      end
+
+      describe '#before' do
+        should 'work' do
+          @code = @code.before(3, 1)
+          @code.should =~ /\A  def self\.main\Z/
+        end
+      end
+
+      describe '#around' do
+        should 'work' do
+          @code = @code.around(3, 1)
+          @code.length.should == 3
+          @code.should =~ /\A  def self/
+          @code.should =~ /  end\Z/
+        end
+      end
+
+      describe '#after' do
+        should 'work' do
+          @code = @code.after(3, 1)
+          @code.should =~ /\A  end\Z/
+        end
+      end
+
+      describe '#grep' do
+        should 'work' do
+          @code = @code.grep(/end/)
+          @code.length.should == 2
+        end
+      end
+    end
+
+    describe 'formatters' do
+      describe '#with_line_numbers' do
+        should 'show line numbers' do
+          @code = @code.with_line_numbers
+          @code.should =~ /1:/
+        end
+
+        should 'disable line numbers when falsy' do
+          @code = @code.with_line_numbers
+          @code = @code.with_line_numbers(false)
+          @code.should.not =~ /1:/
+        end
+      end
+
+      describe '#with_marker' do
+        should 'show a marker in the right place' do
+          @code = @code.with_marker(2)
+          @code.should =~ /^ =>   def self/
+        end
+
+        should 'disable the marker when falsy' do
+          @code = @code.with_marker(2)
+          @code = @code.with_marker(false)
+          @code.should =~ /^  def self/
+        end
+      end
+
+      describe '#with_indentation' do
+        should 'indent the text' do
+          @code = @code.with_indentation(2)
+          @code.should =~ /^    def self/
+        end
+
+        should 'disable the indentation when falsy' do
+          @code = @code.with_indentation(2)
+          @code = @code.with_indentation(false)
+          @code.should =~ /^  def self/
+        end
+      end
+    end
+
+    describe 'composition' do
+      describe 'grep and with_line_numbers' do
+        should 'work' do
+          @code = @code.grep(/end/).with_line_numbers
+          @code.should =~ /\A4:   end/
+          @code.should =~ /5: end\Z/
+        end
+      end
+
+      describe 'grep and before and with_line_numbers' do
+        should 'work' do
+          @code = @code.grep(/e/).before(5, 5).with_line_numbers
+          @code.should =~ /\A2:   def self.main\n3:/
+          @code.should =~ /4:   end\Z/
+        end
+      end
+
+      describe 'before and after' do
+        should 'work' do
+          @code = @code.before(4, 2).after(2)
+          @code.should == "    puts 'Hello, world!'"
+        end
+      end
+    end
+  end
+end