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
    end

    after do
      Object.remove_const(:ClassyWassy)
    end

    it 'should lookup methods' do
      m = Pry::CodeObject.lookup("@obj.ziggy", binding, Pry.new)
      m.is_a?(Pry::Method).should == true
      m.name.to_sym.should == :ziggy
    end

    it 'should lookup modules' do
      m = Pry::CodeObject.lookup("ClassyWassy", binding, Pry.new)
      m.is_a?(Pry::WrappedModule).should == true
      m.source.should =~ /piggy/
    end

    it 'should lookup procs' do
      my_proc = proc { :hello }
      m = Pry::CodeObject.lookup("my_proc", binding, Pry.new)
      m.is_a?(Pry::Method).should == true
      m.source.should =~ /hello/
    end

    describe 'commands lookup' do
      before do
        @p = Pry.new
      end

      it 'should return command class' do
        @p.commands.command "jeremy-jones" do
          "lobster"
        end
        m = Pry::CodeObject.lookup("jeremy-jones", binding, @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", binding, @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", binding, @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", binding, @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, binding, @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

      m = Pry::CodeObject.lookup("o#princess_bubblegum", binding, Pry.new)
      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

      m = Pry::CodeObject.lookup("o.finn", binding, Pry.new)
      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
      m = Pry::CodeObject.lookup("moddy", binding, Pry.new)
      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|
            m = Pry::CodeObject.lookup(v, @b1, Pry.new)
            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|
            m = Pry::CodeObject.lookup(v, @b2, Pry.new)
            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|
            m = Pry::CodeObject.lookup(v, b, Pry.new)
            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
    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", binding, Pry.new, :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", binding, Pry.new, :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
      m = Pry::CodeObject.lookup("jeremy-jones", binding, 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
    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", binding, Pry.new)
      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", binding, Pry.new)
      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")
      o = Pry::CodeObject.lookup("piggy", b, Pry.new)
      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
      o = Pry::CodeObject.lookup("c", binding, Pry.new)
      o.is_a?(Pry::WrappedModule).should == true
      o.wrapped.should == ClassyWassy
    end
  end
end