Q:

Should I use an ActiveRecord has_may-through relation, or a method fetching related items?

I have a FormResponse which belongs_to a Form; the Form then has_many Questions:
class FormResponse < ActiveRecord::Base
   belongs_to :form
end

class Form < ActiveRecord::Base
  has_many :form_responses
  has_many :questions
end

class Question < ActiveRecord::Base
end

When I find myself needing questions in the context of a form, a lot, I prefer to call questions on FormResponse, like so:
form_response = FormResponse.find(id)
form_response.questions

In order to make questions avaiable, I can do this in ActiveRecord:
class FormResponse < ActiveRecord::Base
   belongs_to :form
   has_many :questions, :through => :form
end

or with an instant-method:
class FormResponse < ActiveRecord::Base
  belongs_to :form

  def questions
     self.form.questions unless self.form.nil?
  end
end

I am not interested in setting questions on FormResponse (I won't need
things like FormResponse.questions << or
FormResponse.questions.build), just the fetching.
What are the benefits of using the has_many :questions, :through =>
:form over using a method, and vice-versa? Are there benefits like like lazy-loading, better
SQL and so on?
Does AR give any rules of thumb on when to use an AR-relation and when
to simply write your own methods?

A:

I think this is more a question of encapsulation then of ActiveRecord.
In general I would apply I rule of thumb here:
Use has_many :through when you actually want to model a relation.
Implement a delegation method when all you want to do is not violating the Law of Demeter or keeping your code DRY.

