Ruby » Ruby master

Feature #16430

Updated by MikeVastola (Mike Vastola) almost 5 years ago

I'm not sure if this is intentional (in which case it really isn't documented anywhere, and probably should be) or a bug, but imagine the following code: 

 ``` ruby 
 # lib/a.rb 
 module A 
   FOO = :BAR 
 end 

 # lib/a/b.rb 
 require_relative '../a' 
 module A::B 
   def self.foo foo 
     FOO 
   end 
 end 

 # lib/a/c.rb 
 require_relative '../a' 
 module A 
   module C 
     def self.foo foo 
       FOO 
     end 
   end 
 end 

 ``` 

 If I were to evaluate `A::B.foo`, I would trigger a `NoMethodError (undefined method 'foo' for A::B:Module)`. 
 However, if I were to evaluate `A::C.foo`, I would get `:BAR`. 

 This was really confusing to debug because I've been writing the more compact syntax forever where possible without realizing it impacted variable resolution, and it seems kind of bizarre and counter-intuitive that it would work this way. 


 *    *    *    * 

 Also, playing with this a bit more, there are some really weird artifacts going on: apparently different methods within the same class/module can have different nestings depending on the context in which they were added to the class? 

 For example: 
 ``` ruby 
 module A 
   X = 1 
 end 

 module A::B 
   X = 6 
 end 

 module A 
   module B::C 
     Y = 9 
     Z = X + Y # 10 
   end 
 end 

 module A::B 
   module C 
     N = X + Y # 15 
   end 
 end 

 ``` 

Back