Do modules not execute their own code (such as the 'p "Testing"') below 
in their own namespace, then? I'm doing something that's not at all 
object-oriented, and simply want to ensure that a bunch of methods don't 
leak out into the global namespace. One module will define those 
methods, and other modules (not classes, unless I really have to hack it 
that way) will use the first module, eg.

module Test
    p "Testing"
    eval("def foo\np 'OK'\nend")
end

module Run
    include Test
    foo
end

The above doesn't work, for the reasons you gave, but I still don't 
understand the semantics of why not, I'm afraid. No doubt my Python way 
of thinking. In Python, the equivalent code would create two modules, 
Test and Run, which are effectively just hashmaps mapping names to 
objects. The eval would define a 'foo' object in Test, so there would 
exist a function Test.foo. The include statement in Run (equivalent to 
Python's "from Test import *" I believe) would cause all names in Test 
to be imported into Run, resulting in a 'foo' entry in the Run hashmap; 
this would be Run.foo. Finally, code run within a module always has 
access to the module's namespace (hashmap) for variable lookup, so the 
call on 'foo' within Run would find 'Run.foo' and execute it.

Now, since that interpretation is obviously incorrect in Ruby, could 
someone provide details as to what is actually going on? If possible, I 
prefer explanations of the 'behind-the-scenes' stuff--how variables are 
looked up, namespaces are defined, etc., as understanding the background 
mechanisms will then make everything else pretty easy.

Thanks,
Ken


dblack / rubypal.com wrote:
> Hi --
>
> On Sat, 4 Aug 2007, Kenneth McDonald wrote:
>
>> Simple example that doesn't work:
>>
>> ----------------
>> module Test
>> p "Testing"
>> eval("def foo\np 'OK'\nend")
>> foo
>> end
>> ----------------
>>
>> 'foo' does not get defined in a place where it can be found by the 
>> call on foo, and I get an error. However, when I execute the two lines
>>
>> eval("def foo\np 'OK'\nend")
>> foo
>>
>> in IRB, everything works. I'm guessing that this is a namespace 
>> problem, but can't see why it would be. Then again, I'm accustomed to 
>> the Python namespace model, and still don't understand all of the 
>> ways in which the Ruby model is different.
>
> Your first example is essentially doing this:
>
>   module Test
>     def foo
>       p "OK"
>     end
>
>     foo
>   end
>
> When you define an instance method inside a module, you're defining it
> for the future use of objects with that module in their ancestry:
>
>   class C
>     include Test
>   end
>
>   C.new.foo      # OK
>
>
> David
>