frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


frozen_string_literal: true


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-Active Record models, for example. Active Model also helps with building custom ORMs for use outside of the Rails framework.

You can read more about Active Model in the Active Model Basics guide.

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::API.

class Person
  include ActiveModel::API

  attr_accessor :name, :age
  validates_presence_of :name
end

person = Person.new(name: 'bob', age: '18')
person.name   # => '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::API 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)
      end
    end
    
    person = Person.new
    person.clear_name
    person.clear_age
    

    ActiveModel::AttributeMethods

  • Callbacks for certain operations

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

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

    ActiveModel::Callbacks

  • Tracking value changes

    class Person
      include ActiveModel::Dirty
    
      define_attribute_methods :name
    
      def name
        @name
      end
    
      def name=(val)
        name_will_change! unless val == @name
        @name = val
      end
    
      def save
        # do persistence work
        changes_applied
      end
    end
    
    person = Person.new
    person.name             # => nil
    person.changed?         # => false
    person.name = 'bob'
    person.changed?         # => true
    person.changed          # => ['name']
    person.changes          # => { 'name' => [nil, 'bob'] }
    person.save
    person.name = 'robert'
    person.save
    person.previous_changes # => {'name' => ['bob, 'robert']}
    

    ActiveModel::Dirty

  • Adding errors interface to objects

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

    class Person
    
      def initialize
        @errors = ActiveModel::Errors.new(self)
      end
    
      attr_accessor :name
      attr_reader   :errors
    
      def validate!
        errors.add(:name, "cannot be nil") if name.nil?
      end
    
      def self.human_attribute_name(attr, options = {})
        "Name"
      end
    end
    
    person = Person.new
    person.name = nil
    person.validate!
    person.errors.full_messages
    # => ["Name cannot be nil"]
    

    ActiveModel::Errors

  • Model name introspection

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

    ActiveModel::Naming

  • Making objects serializable

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

    class SerialPerson
      include ActiveModel::Serialization
    
      attr_accessor :name
    
      def attributes
        {'name' => name}
      end
    end
    
    s = SerialPerson.new
    s.serializable_hash   # => {"name"=>nil}
    
    class SerialPerson
      include ActiveModel::Serializers::JSON
    end
    
    s = SerialPerson.new
    s.to_json             # => "{\"name\":null}"
    

    ActiveModel::Serialization

  • Internationalization (i18n) support

    class Person
      extend ActiveModel::Translation
    end
    
    Person.human_attribute_name('my_attribute')
    # => "My attribute"
    

    ActiveModel::Translation

  • 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.start_with?("z")
      end
    end
    
    person = Person.new
    person.first_name = 'zoolander'
    person.valid?  # => false
    

    ActiveModel::Validations

  • Custom validators

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

    ActiveModel::Validator

Download and installation

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

$ gem install activemodel

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

  • github.com/rails/rails/tree/main/activemodel

License

Active Model is released under the MIT license:

  • opensource.org/licenses/MIT

Support

API documentation is at:

  • api.rubyonrails.org

Bug reports for the Ruby on Rails project can be filed here:

  • github.com/rails/rails/issues

Feature requests should be discussed on the rails-core mailing list here:

  • discuss.rubyonrails.org/c/rubyonrails-core

Show files where this module is defined (70 files)
Register or log in to add new notes.