require File.expand_path('../../../spec_helper', __FILE__)
require File.expand_path('../fixtures/classes', __FILE__)

describe "Kernel#define_singleton_method" do
  describe "when given an UnboundMethod" do
    class DefineSingletonMethodSpecClass
      MY_CONST = 42
      define_singleton_method(:another_test_method, self.method(:constants))
    end

    it "correctly calls the new method" do
      klass = DefineSingletonMethodSpecClass
      klass.another_test_method.should == klass.constants
    end

    it "adds the new method to the methods list" do
      DefineSingletonMethodSpecClass.should have_method(:another_test_method)
    end

    ruby_bug "redmine:2117", "1.8.7" do
      it "defines any Child class method from any Parent's class methods" do
        um = KernelSpecs::Parent.method(:parent_class_method).unbind
        KernelSpecs::Child.send :define_singleton_method, :child_class_method, um
        KernelSpecs::Child.child_class_method.should == :foo
        lambda{KernelSpecs::Parent.child_class_method}.should raise_error(NoMethodError)
      end

      it "will raise when attempting to define an object's singleton method from another object's singleton method" do
        other = KernelSpecs::Parent.new
        p = KernelSpecs::Parent.new
        class << p
          def singleton_method
            :single
          end
        end
        um = p.method(:singleton_method).unbind
        lambda{ other.send :define_singleton_method, :other_singleton_method, um }.should raise_error(TypeError)
      end
    end

  end

  it "defines a new method with the given name and the given block as body in self" do
    class DefineSingletonMethodSpecClass
      define_singleton_method(:block_test1) { self }
      define_singleton_method(:block_test2, &lambda { self })
    end

    o = DefineSingletonMethodSpecClass
    o.block_test1.should == o
    o.block_test2.should == o
  end

  it "raises a TypeError when the given method is no Method/Proc" do
    lambda {
      Class.new { define_singleton_method(:test, "self") }
    }.should raise_error(TypeError)

    lambda {
      Class.new { define_singleton_method(:test, 1234) }
    }.should raise_error(TypeError)
  end

  it "defines a new singleton method for objects" do
    s = "hello"
    s.define_singleton_method(:test) { "world!" }
    s.test.should == "world!"
    lambda {
      "hello".test
    }.should raise_error(NoMethodError)
  end

  it "maintains the Proc's scope" do
    class DefineMethodByProcClass
      in_scope = true
      method_proc = proc { in_scope }

      define_singleton_method(:proc_test, &method_proc)
    end

    DefineMethodByProcClass.proc_test.should == true
  end
end
