how to define/attach rails validations in multiple generations of modules

I've found a way to make this work, but am curious about a better way / the Rails 3 way. (I'm using 2.3.5 still, but hope to migrate around New Year's.)

The situation: I've got two layers of module inheritance, the second layer gets mixed into a Rails model. Both modules define validation methods and I'd like both of them to attach the validations to the base class, but because of the two levels of inheritance, the following doesn't work:

def self.included(base)
  base.validate :yadda_yadda
end

When that module is included by another module, the interpreter grinds to a scr开发者_JAVA百科eeching halt because Modules don't know about ActiveRecord::Validations. Including the validations module begs the question of "where is save?" thanks to alias_method.

The following works, as long as you remember to call super whenever you override validate(). I don't trust myself or future maintainers to remember that, so I'd like to use the validate :yadda_yadda idiom instead, if possible.

module Grandpa

  def validate
    must_be_ok
  end

  def must_be_ok
    errors.add_to_base("#{self} wasn't ok")
  end

end

module Dad

  include Grandpa

  def validate
    super
    must_be_ok_too
  end

  def must_be_ok_too
    errors.add_to_base("#{self} wasn't ok either")
  end

end

class Kid  < ActiveRecord::Base

  include Dad

  validate :must_be_ok_three

  def must_be_ok_three
    errors.add_to_base("#{self} wasn't ok furthermore")
  end

end

Suggestions? Tips for Rails 3 approach? I don't think the validations API has changed that much.

I solved it (when I ran into the same problem, but with something other than validation).

Short answer: you can call send(:included, base) on the module you want to bring in. Within the higher-up included() definition, you need to check whether the base is a Class or a Module.

Why would you ever want to do this? Well, I've got some modules that extract some common functionality out of my models. For instance, the module HasAllocable sets up a polymorphic belongs_to relationship, and a getter/setter pair for a virtual attribute. Now I have another module that needs to pull in HasAllocable, to spare the base classes from having to remember it.

I'd be interested to know whether this smells funny to anyone. I haven't seen anything like it on the web, so I wonder if multiple layers of model inheritance is more of an antipattern.

module Grandpa

  def self.included(base)
    if base.kind_of?(Class)
      base.validate :must_be_ok
    end
  end

end

module Dad

  include Grandpa

  def self.included(base)
    if base.kind_of?(Class)
      # you can do this
      #base.send(:include, Grandpa)
      # you can also do this
      Grandpa.send(:included, base)
      # this does not invoke Grandpa.included(Kid)
      #super(base)

      base.validate :must_be_ok_too
    end
  end

end

class Kid  < ActiveRecord::Base
  include Dad
  validate :must_be_ok_three
end