Question

Here’s a question to bamboozle your noodle.

It seems there’s a difference between method declaration and constant declaration in a block that is evaluated using class_eval with a class as the receiver. Here’s some code that demonstrates the discrepancy:

module X
  def save_block(&block)
    @block = block
  end
end

module Y
  extend X
  save_block do
    SOME_CONSTANT = 1
    def meth
      "a method"
    end
  end
  def self.included(m)
    m.class_eval &@block
  end
end

class Z
  include Y
end

class W
  include Y
end

Executing this code, at least in Ruby 1.9.3, results in the following error:

warning: already initialized constant SOME_CONSTANT

Which I didn’t expect. Consider first where meth is located:

Z.instance_methods(false)
=> [:meth]

W.instance_methods(false)
=> [:meth]

And Y doesn’t have any instance methods:

Y.instance_methods(false)
=> []

This makes sense because the block is executed with Z and W as the receivers of class_eval. However, the constants are different, hence the error message, as shown here:

Y.constants(false)
=> [:SOME_CONSTANT]

Z.constants(false) 
=> []

W.constants(false)
=> []

Here, the constant ends up getting defined in Y (for some bizarre reason) and thus when the block is executed a second time, the constant, SOME_CONSTANT is already defined.

I very much look forward to some enlightenment.

Update (2012/11/19):

As @phoet pointed out below (the the response to my comment to his answer), constants are defined in the lexical scope of the block, that is to say, in the scope where the block is originally defined. In my example, this would be Y.

Answer 1

as described in this question Accessing a constant constant handling is within it’s “lexical scope”, meaning the context they are defined, not the context they are executed.