Rails single-table inheritance: determining class programmatically

Question

In my Rails application, I am implementing a survey-like form which allows users to fill out answers to a dynamically changeable set of questions. Currently, I'm planning to support three different "types" of questions: Yes/No, Rating (on a 1-5 scale), and Text. For each of these question types, I need slightly different behavior for the corresponding Answer model (to accommodate different methods, validation requirements, etc). I am currently trying to implement these different behaviors using single table inheritance, like so:

class Question < ActiveRecord::Base
  validates_presence_of :question_type

  # ...
end

class Answer < ActiveRecord::Base
  belongs_to :question

  validates_presence_of :answer

  # ...
end

class YesNoAnswer < Answer
  validates :answer, inclusion: {in: %w(Yes No N/A)}

  # ...
end

class RatingAnswer < Answer
  validates :answer, numericality: { only_integer: true }, inclusion: {in: 1..5}

  def answer
    self[:answer].to_i
  end

  # ...
end

class TextAnswer < Answer
  validates :answer, length: { minimum: 2 }

  # ...
end

The problem is that with single-table inheritance the chosen class is normally determined by a field in the database for each record. (By default, this field is "type", but you can change this by setting inheritance_column).

In my case though, the type of the answer should always match the type of its corresponding question, making the need to manage an extra database field like this awkward and redundant. So rather than rely strictly on what's in the database, I want to determine programmatically what class should be used for a given record. E.g.:

class Answer < ActiveRecord::Base
  # I want a value on the associated question to determine this record's type.
  # Simply defining a type method as shown here doesn't work though.
  def type
    question.try(:question_type)
  end
end

Is this possible? If so, how?

Tilo Tilo · Accepted Answer · 2014-08-20T16:15:13

inheritance_column does not determine the Class, it stores the name of the type column, which then determines what Class to use for the given record.

So by changing the inheritance_column value, you can store what you would usually store in the type column in another column.

This would not help you to dynamically determine where the Class name is stored, because it just points to another column which then determines the Class by the value in that column.

See also: http://apidock.com/rails/ActiveRecord/ModelSchema/ClassMethods/inheritance_column

Single-Table-Inheritance (STI) is specifically meant for the case that you want to persist models which are somewhat alike, but which persist different attributes depending on type. In other words: You shouldn't use STI unless you want to persist different things in the model.

If you just want different behavior depending on the kind of question, you could do this: depending on the kind of question, you extend the Answer instance with the behavior you like by calling extend on the necessary Ruby module:

class Question < ActiveRecord::Base
  validates_presence_of :kind
  has_many :answers
  # ... contains an attribute 'kind' to determine the kind of question
end

class Answer < ActiveRecord::Base
  belongs_to :question
  validates_presence_of :answer

  # when a new instance of Answer is created, it automatically extends itself's 
  # behavior from the given Ruby Module, which is conveniently stored as a Rails Concern
  def initialize
    case question.kind
    when 'yes_no'
      self.class.send(:extend, YesNo)
    when 'rating'
      self.class.send(:extend, Rating)
    when 'text'
      self.class.send(:extend, Text)
    else
      # ...
    end
  end

end

and in your ./app/models/concerns you have different files containing the modules which define the behavior you want to add to the Answer class depending on kind of question:

 # file concerns/yes_no.rb
 module YesNo
  validates :answer, inclusion: {in: %w(Yes No N/A)}
 end

 # file concerns/rating.rb
 module Rating
  validates :answer, numericality: { only_integer: true }, inclusion: {in: 1..5}  

  def answer
   self[:answer].to_i
  end
  # ...
end

# file concerns/text.rb
module Text
  validates :answer, length: { minimum: 2 }
end

To beautify the code some more, you could put those answer-behaviors into a sub-directory './concerns/answer_behavior/', and wrap them in a module 'AnswerBehavior'.

Rails single-table inheritance: determining class programmatically

2 Answers