Skip to content
Find file
Fetching contributors…
Cannot retrieve contributors at this time
241 lines (163 sloc) 6.2 KB

Active Model – model interfaces for Rails

Active Model provides a known set of interfaces for usage in model classes. They allow for Action Pack helpers to interact with non-ActiveRecord models, for example. Active Model also helps building custom ORMs for use outside of the Rails framework.

Prior to Rails 3.0, if a plugin or gem developer wanted to have an object interact with Action Pack helpers, it was required to either copy chunks of code from Rails, or monkey patch entire helpers to make them handle objects that did not exactly conform to the Active Record interface. This would result in code duplication and fragile applications that broke on upgrades. Active Model solves this by defining an explicit API. You can read more about the API in ActiveModel::Lint::Tests.

Active Model provides a default module that implements the basic API required to integrate with Action Pack out of the box: ActiveModel::Model.

class Person
  include ActiveModel::Model

  attr_accessor :name, :age
  validates_presence_of :name

person = => 'bob', :age => '18') # => 'bob'
person.age # => '18'
person.valid? # => true

It includes model name introspections, conversions, translations and validations, resulting in a class suitable to be used with Action Pack. See ActiveModel::Model for more examples.

Active Model also provides the following functionality to have ORM-like behavior out of the box:

  • Add attribute magic to objects

    class Person
      include ActiveModel::AttributeMethods
      attribute_method_prefix 'clear_'
      define_attribute_methods :name, :age
      attr_accessor :name, :age
      def clear_attribute(attr)
        send("#{attr}=", nil)

    Learn more

  • Callbacks for certain operations

    class Person
      extend ActiveModel::Callbacks
      define_model_callbacks :create
      def create
        run_callbacks :create do
          # Your create action methods here

    This generates before_create, around_create and after_create class methods that wrap your create method.

    Learn more

  • Tracking value changes

    The ActiveModel::Dirty module allows for tracking attribute changes:

    person = # => nil
    person.changed? # => false = 'bob'
    person.changed? # => true
    person.changed # => ['name']
    person.changes # => { 'name' => [nil, 'bob'] } = 'robert'
    person.previous_changes # => {'name' => ['bob, 'robert']}

    Learn more

  • Adding errors interface to objects

    Exposing error messages allows objects to interact with Action Pack helpers seamlessly.

    class Person
      def initialize
        @errors =
      attr_accessor :name
      attr_reader   :errors
      def validate!
        errors.add(:name, "can not be nil") if name.nil?
      def self.human_attribute_name(attr, options = {})
    # => ["Name can not be nil"]

    Learn more

  • Model name introspection

    class NamedPerson
      extend ActiveModel::Naming
    NamedPerson.model_name        # => "NamedPerson"
    NamedPerson.model_name.human  # => "Named person"

    Learn more

  • Observer support

    ActiveModel::Observers allows your object to implement the Observer pattern in a Rails App and take advantage of all the standard observer functions.

    class PersonObserver < ActiveModel::Observer
      def after_create(person)"New person added!")
      def after_destroy(person)
        person.logger.warn("Person with an id of #{} was destroyed!")

    Learn more

  • Making objects serializable

    ActiveModel::Serialization provides a standard interface for your object to provide to_json or to_xml serialization.

    s =
    s.serializable_hash   # => {"name"=>nil}
    s.to_json             # => "{\"name\":null}"
    s.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...

    Learn more

  • Internationalization (i18n) support

    class Person
      extend ActiveModel::Translation
    # => "My attribute"

    Learn more

  • Validation support

    class Person
      include ActiveModel::Validations
      attr_accessor :first_name, :last_name
      validates_each :first_name, :last_name do |record, attr, value|
        record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
    person =
    person.first_name = 'zoolander'
    person.valid?  # => false

    Learn more

  • Custom validators

    class ValidatorPerson
      include ActiveModel::Validations
      validates_with HasNameValidator
      attr_accessor :name
    class HasNameValidator < ActiveModel::Validator
      def validate(record)
        record.errors[:name] = "must exist" if
    p =
    p.valid?                  # =>  false
    p.errors.full_messages    # => ["Name must exist"] = "Bob"
    p.valid?                  # =>  true

    Learn more

Download and installation

The latest version of Active Model can be installed with RubyGems:

% [sudo] gem install activemodel

Source code can be downloaded as part of the Rails project on GitHub


Active Model is released under the MIT license:


API documentation is at

Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:

Jump to Line
Something went wrong with that request. Please try again.