Re: Nesting and constants

On Tue, Aug 7, 2012 at 4:02 PM, Thomas Thomassen <[e-mail]>wrote:

module TT_Test
>
>   module Foo
>     CHEESE = 'I am Foo!'
>     module Bar
>       def self.prod
>         puts CHEESE
>       end
>       def self.q
>       p Module.nesting
>     end
>     end # Bar
>     def self.q
>       p Module.nesting
>     end
>   end # Foo
>
>
>   module Foo::Biz
>     def self.prod
>       puts CHEESE
>     end
>     def self.q
>       p Module.nesting
>     end
>   end # Foo
>
> end # TT_Test
>
>
> TT_Test::Foo.q
> # => [TT_Test::Foo, TT_Test]
>
> TT_Test::Foo::Bar.q
> # => [TT_Test::Foo::Bar, TT_Test::Foo, TT_Test]
>
> TT_Test::Foo::Bar.q
> # => [TT_Test::Foo::Bar, TT_Test]
>
> TT_Test::Foo.constants
> # => ["Biz", "Bar", "CHEESE"]
>
> My question is: Why is the constant scope different between Bar and Biz
> - despite that they both exist under TT_Test::Foo ? I mean, if TT_Test
> got a constant named "Foo::Biz" I would have understood the constant
> lookup.
>


The module keyword pushes to the nesting the module it has opened (either
just created or reopened).

Therefore, in

    module M
      module N
        p Module.nesting # => [M::N, M]
      end
    end

because first we open M, and then in a nested call we open M::N. But on the
other hand

    module M::N
      p Module.nesting # => [M::N]
    end

opens M::N and that's it. Nesting gets just that one module object pushed.

Note that what we push are module objects, not constants:

    module M
    end

    N = M

    module N
      p Module.nesting # => [M]
    end

In the example above, N evaluates to the module object stored in the
constant M, that's the module object being reopened and therefore pushed to
the nesting.