Extracting common ActiveRecord code for similar clases - ruby

Question

I have the following classes defined that have a lot of common code with minor variations.
class ThirdPartyComponent < ActiveRecord::Base
belongs_to :prev_version, :class_name => 'ThirdPartyComponent', :foreign_key => 'prev_version_id'
has_one :next_version, :class_name => 'ThirdPartyComponent', :foreign_key => 'prev_version_id'
attr_accessible :name, :version, :installer, :install_script
mount_uploader :installer, ComponentFileUploader
mount_uploader :install_script, ComponentFileUploader
validates :name, :presence => true
validates :version, :presence => true, :format => { :with => /\A\d{1,3}\.\d{1,2}\z/ }
validates :installer, :presence => true
validates :install_script, :presence => true
validate :increased_version
def increased_version
# Check to ensure that version number is greater than the previous version number for the same component set
unless prev_version.nil?
version > prev_version.version
end
end
def all_previous_versions
prev_versions = all_versions
prev_versions.shift
prev_versions
end
def all_versions
current_version = self
all_versions = [current_version]
while !current_version.prev_version.nil?
all_versions << current_version.prev_version
current_version = current_version.prev_version
end
all_versions
end
end
class RegistryComponent < ActiveRecord::Base
belongs_to :prev_version, :class_name => 'RegistryComponent', :foreign_key => 'prev_version_id'
has_one :next_version, :class_name => 'RegistryComponent', :foreign_key => 'prev_version_id'
attr_accessible :name, :version, :registry_file
mount_uploader :registry_file, ComponentFileUploader
validates :name, :presence => true
validates :version, :presence => true, :format => { :with => /\A\d{1,3}\.\d{1,2}\z/ }
validates :registry_file, :presence => true
validate :increased_version
def increased_version
# Check to ensure that version number is greater than the previous version number for the same component set
unless prev_version.nil?
version > prev_version.version
end
end
def all_previous_versions
prev_versions = all_versions
prev_versions.shift
prev_versions
end
def all_versions
current_version = self
all_versions = [current_version]
while !current_version.prev_version.nil?
all_versions << current_version.prev_version
current_version = current_version.prev_version
end
all_versions
end
end
I'm also looking at adding some other components in the future, again with very similar functionality.
I want to extract the common code from these classes into a single file (including the ActiveRecord method calls such as validates, etc.) and then just reference them in the concrete classes.
So far I've tried,
inheritance - I created a base class that inherited from ActiveRecord and then each class inherited from the base class. Result: Rails complained that it couldn't find a database table whose name matched the base class.
inheritance - I considered creating the base class as tableless model instead (see http://railscasts.com/episodes/219-active-model) but then I realised that the concrete classes would also be lacking the full ActiveRecord functionality
composition - I tried defining the common code in a module and then using include or extend in the concrete classes to access it as shown below.
module ComponentBase
belongs_to :prev_version, :class_name => self.class.name, :foreign_key => 'prev_version_id'
has_one :next_version, :class_name => self.class.name, :foreign_key => 'prev_version_id'
attr_accessible :name, :version
validates :name, :presence => true
validates :version, :presence => true, :format => { :with => /\A\d{1,3}\.\d{1,2}\z/ }
validate :increased_version
def increased_version
# Check to ensure that version number is greater than the previous version number for the same component set
unless prev_version.nil?
version > prev_version.version
end
end
def all_previous_versions
prev_versions = all_versions
prev_versions.shift
prev_versions
end
def all_versions
current_version = self
all_versions = [current_version]
while !current_version.prev_version.nil?
all_versions << current_version.prev_version
current_version = current_version.prev_version
end
all_versions
end
end
class RegistryComponent < ActiveRecord::Base
include ComponentBase
attr_accessible :registry_file
mount_uploader :registry_file, ComponentFileUploader
validates :registry_file, :presence => true
end
This resulted in an error that the belongs_to method is not defined for ComponentBase. This looks the most promising solution but is there any way to execute the ActiveRecord class methods within the context of the class that includes them? Alternatively, is there a better way for me to achieve the same aims?

Answer 1

Your first option was actually the best option. Rails uses Single Table Inheritance, which means the data for all of your subclasses is kept in the same table which is why you got the error you did.
What you should do is create a new model called Component and add to it all the fields that are common across all of your components as well as one extra field called type that should be a string field.
Your Component model will then have all the common fields, logic, and validations.
class Component < ActiveRecord::Base
...
end
Then have have each of your compontent classes subclass Component.
class ThirdPartyComponent < Component
...
end

Answer 2

I stumbled across the following answer at Extending a Ruby class with a standalone piece of code and with a bit of experimentation got it to work. So the final code I ended up with was,
module ComponentBase
def self.included(base)
base.class_eval do
belongs_to :prev_version, :class_name => base, :foreign_key => 'prev_version_id'
has_one :next_version, :class_name => base, :foreign_key => 'prev_version_id'
attr_accessible :name, :version
validates :name, :presence => true
validates :version, :presence => true, :format => { :with => /\A\d{1,3}\.\d{1,2}\z/ }
validate :increased_version
end
end
def increased_version
# Check to ensure that version number is greater than the previous version number for the same component set
unless prev_version.nil?
version > prev_version.version
end
end
def all_previous_versions
prev_versions = all_versions
prev_versions.shift
prev_versions
end
def all_versions
current_version = self
all_versions = [current_version]
while !current_version.prev_version.nil?
all_versions << current_version.prev_version
current_version = current_version.prev_version
end
all_versions
end
end
class RegistryComponent < ActiveRecord::Base
include ComponentBase
attr_accessible :registry_file
mount_uploader :registry_file, ComponentFileUploader
validates :registry_file, :presence => true
end
The solution was to use the included callback which is called each time the module is included somewhere else. Then, call class_eval on the base module to run the methods in the class context (i.e. as class methods). The trickiest part was getting the class name in this context but it simply turned out that I could use base (not entirely sure why this is the case but it works).

Answer 3

The issue is that you need the belongs_to method to run on the class that is including the module, not the module itself.
Check out module#included http://www.ruby-doc.org/core-2.0/Module.html#method-i-included, which will allow you to run code on the module you are including your module into. Remmeber that Module is an ancestor of Class so this works for classes and modules.
In this case you will want to run belongs_to on the class that the module is being included into, so something like the following should act as an example you can work off of:
module ComponentBase
def self.included(mod)
mod.class_eval do
belongs_to :prev_version, :class_name => self.class.name, :foreign_key => 'prev_version_id'
end
end
end