require_relative '../../spec_helper'
require_relative 'fixtures/classes'

context "Creating UnboundMethods" do
  specify "there is no difference between Method#unbind and Module#instance_method" do
    UnboundMethodSpecs::Methods.instance_method(:foo).should.is_a?(UnboundMethod)
    UnboundMethodSpecs::Methods.new.method(:foo).unbind.should.is_a?(UnboundMethod)
  end
end

describe "UnboundMethod#==" do
  before :all do
    @from_module = UnboundMethodSpecs::Methods.instance_method(:foo)
    @from_unbind = UnboundMethodSpecs::Methods.new.method(:foo).unbind

    @with_block = UnboundMethodSpecs::Methods.instance_method(:with_block)

    @includee = UnboundMethodSpecs::Mod.instance_method(:from_mod)
    @includer = UnboundMethodSpecs::Methods.instance_method(:from_mod)

    @alias_1 = UnboundMethodSpecs::Methods.instance_method(:alias_1)
    @alias_2 = UnboundMethodSpecs::Methods.instance_method(:alias_2)

    @original_body = UnboundMethodSpecs::Methods.instance_method(:original_body)
    @identical_body = UnboundMethodSpecs::Methods.instance_method(:identical_body)

    @parent = UnboundMethodSpecs::Parent.instance_method(:foo)
    @child1 = UnboundMethodSpecs::Child1.instance_method(:foo)
    @child2 = UnboundMethodSpecs::Child2.instance_method(:foo)

    @child1_alt = UnboundMethodSpecs::Child1.instance_method(:foo)

    @discard_1 = UnboundMethodSpecs::Methods.instance_method(:discard_1)
    @discard_2 = UnboundMethodSpecs::Methods.instance_method(:discard_2)

    @method_one = UnboundMethodSpecs::Methods.instance_method(:one)
    @method_two = UnboundMethodSpecs::Methods.instance_method(:two)

    @mixin = UnboundMethodSpecs::Mixin.instance_method(:mixin_method)
    @includer_base = UnboundMethodSpecs::IncluderBase.new.method(:mixin_method).unbind
    @includer_child = UnboundMethodSpecs::IncluderChild.new.method(:mixin_method).unbind
    @extender_base = UnboundMethodSpecs::ExtenderBase.method(:mixin_method).unbind
    @extender_child = UnboundMethodSpecs::ExtenderChild.method(:mixin_method).unbind
  end

  it "returns true if objects refer to the same method" do
    (@from_module == @from_module).should == true
    (@from_unbind == @from_unbind).should == true
    (@from_module == @from_unbind).should == true
    (@from_unbind == @from_module).should == true
    (@with_block  == @with_block).should == true
  end

  it "returns true if either is an alias for the other" do
    (@from_module == @alias_1).should == true
    (@alias_1 == @from_module).should == true
  end

  it "returns true if both are aliases for a third method" do
    (@from_module == @alias_1).should == true
    (@alias_1 == @from_module).should == true

    (@from_module == @alias_2).should == true
    (@alias_2 == @from_module).should == true

    (@alias_1 == @alias_2).should == true
    (@alias_2 == @alias_1).should == true
  end

  it "returns true if same method is extracted from the same subclass" do
    (@child1 == @child1_alt).should == true
    (@child1_alt == @child1).should == true
  end

  it "returns false if UnboundMethods are different methods" do
    (@method_one == @method_two).should == false
    (@method_two == @method_one).should == false
  end

  it "returns false if both have identical body but are not the same" do
    (@original_body == @identical_body).should == false
    (@identical_body == @original_body).should == false
  end

  it "returns true if same method but one extracted from a subclass" do
    (@parent == @child1).should == true
    (@child1 == @parent).should == true
  end

  it "returns true if same method but extracted from two different subclasses" do
    (@child2 == @child1).should == true
    (@child1 == @child2).should == true
  end

  it "returns true if methods are the same but added from an included Module" do
    (@includee == @includer).should == true
    (@includer == @includee).should == true
  end

  ruby_bug "#21873", ""..."4.1" do
    it "returns true if same method is present in an object through module inclusion" do
      (@mixin == @includer_base).should == true
      (@includer_base == @mixin).should == true

      (@mixin == @includer_child).should == true
      (@includer_child == @mixin).should == true

      (@includer_base == @includer_child).should == true
      (@includer_child == @includer_base).should == true
    end

    it "returns true if same method is present in an object through module extension" do
      (@mixin == @extender_base).should == true
      (@extender_base == @mixin).should == true

      (@mixin == @extender_child).should == true
      (@extender_child == @mixin).should == true

      (@extender_base == @extender_child).should == true
      (@extender_child == @extender_base).should == true
    end
  end

  it "returns false if both have same Module, same name, identical body but not the same" do
    class UnboundMethodSpecs::Methods
      def discard_1; :discard; end
    end

    (@discard_1 == UnboundMethodSpecs::Methods.instance_method(:discard_1)).should == false
  end

  it "returns false for two attr_reader methods" do
    Class.new do
      attr_reader :a, :b
      instance_method(:a).should_not == instance_method(:b)
    end
  end

  it "considers methods through aliasing equal" do
    c = Class.new do
      class << self
        alias_method :n, :new
      end
    end

    c.method(:new).should == c.method(:n)
    c.method(:n).should == Class.instance_method(:new).bind(c)
  end

  it "considers methods through visibility change equal" do
    c = Class.new do
      class << self
        private :new
      end
    end

    c.method(:new).should == Class.instance_method(:new).bind(c)
  end

  it "considers methods through aliasing and visibility change equal" do
    c = Class.new do
      class << self
        alias_method :n, :new
        private :new
      end
    end

    c.method(:new).should == c.method(:n)
    c.method(:n).should == Class.instance_method(:new).bind(c)
    c.method(:new).should == Class.instance_method(:new).bind(c)
  end
end
