rails--rails/activemodel/README

= Active Model - defined interfaces for Rails

Prior to Rails 3.0, if a plugin or gem developer wanted to be able 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 look like Active Record.  This generated code
duplication and fragile applications that broke on upgrades.

Active Model is a solution for this problem.

Active Model provides a known set of interfaces that your objects can implement
to then present a common interface to the Action Pack helpers.  You can include
functionality from the following modules:

* Adding attribute magic to your objects

    Add prefixes and suffixes to defined attribute methods...
    
    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
    
    ...gives you clear_name, clear_age.
  
  {Learn more}[link:classes/ActiveModel/AttributeMethods.html]
  
* Adding callbacks to your objects

    class Person
      extend ActiveModel::Callbacks
      define_model_callbacks :create
    
      def create
        _run_create_callbacks do
          # Your create action methods here
        end
      end
    end
    
    ...gives you before_create, around_create and after_create class methods that
    wrap your create method.
   
  {Learn more}[link:classes/ActiveModel/CallBacks.html]

* For classes that already look like an Active Record object

    class Person
      include ActiveModel::Conversion
    end
    
    ...returns the class itself when sent :to_model

   {Learn more}[link:classes/ActiveModel/Conversion.html]

* Tracking changes in your object

    Provides all the value tracking features implemented by ActiveRecord...
    
    person = Person.new
    person.name # => nil
    person.changed? # => false
    person.name = 'bob'
    person.changed? # => true
    person.changed # => ['name']
    person.changes # => { 'name' => [nil, 'bob'] }
    person.name = 'robert'
    person.save
    person.previous_changes # => {'name' => ['bob, 'robert']}

  {Learn more}[link:classes/ActiveModel/Dirty.html]

* Adding +errors+ support to your object

    Provides the error messages to allow your object 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, "can not be nil") if name == nil
      end

      def ErrorsPerson.human_attribute_name(attr, options = {})
        "Name"
      end

    end
    
    ... gives you...
    
    person.errors.full_messages
    # => ["Name Can not be nil"]
    person.errors.full_messages
    # => ["Name Can not be nil"]

  {Learn more}[link:classes/ActiveModel/Errors.html]

* Testing the compliance of your object

    Use ActiveModel::Lint to test the compliance of your object to the
    basic ActiveModel API...
    
  {Learn more}[link:classes/ActiveModel/Lint/Tests.html]

* Providing a human face to your object

    ActiveModel::Naming provides your model with the model_name convention
    and a human_name attribute...
    
    class NamedPerson
      extend ActiveModel::Naming
    end
    
    ...gives you...
    
    NamedPerson.model_name        #=> "NamedPerson"
    NamedPerson.model_name.human  #=> "Named person"

  {Learn more}[link:classes/ActiveModel/Naming.html]

* Adding observer support to your objects

    ActiveModel::Observers allows your object to implement the Observer
    pattern in a Rails App and take advantage of all the standard observer
    functions.
  
  {Learn more}[link:classes/ActiveModel/Observer.html]

* Making your object serializable

    ActiveModel::Serialization provides a standard interface for your object
    to provide to_json or to_xml serialization...
    
    s = SerialPerson.new
    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}[link:classes/ActiveModel/Serialization.html]
    

* Turning your object into a finite State Machine

    ActiveModel::StateMachine provides a clean way to include all the methods
    you need to transform your object into a finite State Machine...

    light = TrafficLight.new
    light.current_state       #=> :red
    light.change_color!       #=> true
    light.current_state       #=> :green

  {Learn more}[link:classes/ActiveModel/StateMachine.html]

* Integrating with Rail's internationalization (i18n) handling through
  ActiveModel::Translations...

    class Person
      extend ActiveModel::Translation
    end
  
  {Learn more}[link:classes/ActiveModel/Translation.html]

* Providing a full Validation stack for your objects...

   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
     end
   end

   person = Person.new(:first_name => 'zoolander')
   person.valid?          #=> false

  {Learn more}[link:classes/ActiveModel/Validations.html]