Supposing I have a model sample, and column foo for the model samples in the DB. In the following example, what does Sample.find(:first).wtf print out?
require 'sampletwo'
class Sample < ActiveRecord::Base
def wtf
foo
end
def foo
"here 1"
end
end
def foo
"here 2"
end
Too easy, the answer is "here 1". Ok how about something a bit harder. What does Sample.find(:first).wtf print out now?
class Sample < ActiveRecord::Base
def wtf
foo
end
end
Is it the column on the database? No. It's the method foo in the library sampletwo.rb, which you won't know. But is now imported in environment.rb. The order for lookup (if I've got this right is):
- Does the method exist on the object (and presumably in the inheritance tree, but not sure)
- Does the method exist somewhere else in the namespace, eg in the module
- Does anything else import that value into the namespace, eg any
requireyou might have in your environment or your current model - Lookup the database column
I've never like the fact that Ruby's require imports everything into that namespace the module wants to import, you don't have any choice. It's rather like this in Python:
from wx import *
The end result is that when you collaborate on things or end with big honking 2,000 line models you get a huge amount of conflict and sitting there trying to figure out where something comes from. You normally keep your database manager open in another window so you can query it and see what's there.
Meanwhile in Django land, there's an explicit model, explicit import statements (* imports are possible but discouraged in Python) and explicit use of self.