Module: ActiveModel::AttributeMethods

### Home Classes Methods

### In Files

- lib/active_model/attribute_methods.rb

### Namespace

- MODULE ActiveModel::AttributeMethods::ClassMethods

### Methods

- #attribute_method?
- #attribute_missing
- #method_missing
- #respond_to?
- #respond_to_without_attributes?

### Class/Module Index

Quicksearch

- ActiveModel
- ActiveModel::AttributeMethods
- ActiveModel::AttributeMethods::ClassMethods
- ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
- ActiveModel::BlockValidator
- ActiveModel::Callbacks
- ActiveModel::Conversion
- ActiveModel::Dirty
- ActiveModel::EachValidator
- ActiveModel::Errors
- ActiveModel::Lint
- ActiveModel::Lint::Tests
- ActiveModel::MassAssignmentSecurity
- ActiveModel::MassAssignmentSecurity::BlackList
- ActiveModel::MassAssignmentSecurity::ClassMethods
- ActiveModel::MassAssignmentSecurity::Error
- ActiveModel::MassAssignmentSecurity::LoggerSanitizer
- ActiveModel::MassAssignmentSecurity::PermissionSet
- ActiveModel::MassAssignmentSecurity::Sanitizer
- ActiveModel::MassAssignmentSecurity::StrictSanitizer
- ActiveModel::MassAssignmentSecurity::WhiteList
- ActiveModel::MissingAttributeError
- ActiveModel::Name
- ActiveModel::Naming
- ActiveModel::Observer
- ActiveModel::ObserverArray
- ActiveModel::Observing
- ActiveModel::Observing::ClassMethods
- ActiveModel::SecurePassword
- ActiveModel::SecurePassword::ClassMethods
- ActiveModel::SecurePassword::InstanceMethodsOnActivation
- ActiveModel::Serialization
- ActiveModel::Serializers
- ActiveModel::Serializers::JSON
- ActiveModel::Serializers::Xml
- ActiveModel::StrictValidationFailed
- ActiveModel::Translation
- ActiveModel::Validations
- ActiveModel::Validations::AcceptanceValidator
- ActiveModel::Validations::Callbacks
- ActiveModel::Validations::Callbacks::ClassMethods
- ActiveModel::Validations::ClassMethods
- ActiveModel::Validations::ConfirmationValidator
- ActiveModel::Validations::ExclusionValidator
- ActiveModel::Validations::FormatValidator
- ActiveModel::Validations::HelperMethods
- ActiveModel::Validations::InclusionValidator
- ActiveModel::Validations::LengthValidator
- ActiveModel::Validations::NumericalityValidator
- ActiveModel::Validations::PresenceValidator
- ActiveModel::Validations::WithValidator
- ActiveModel::Validator

No matching classes.

# ActiveModel::AttributeMethods

## Active Model Attribute Methods

`ActiveModel::AttributeMethods` provides a way to add prefixes and suffixes to your methods as well as handling the creation of Active Record like class methods such as `table_name`.

The requirements to implement ActiveModel::AttributeMethods are to:

- `include ActiveModel::AttributeMethods` in your object

- Call each Attribute Method module method you want to add, such as attribute_method_suffix or attribute_method_prefix

- Call `define_attribute_methods` after the other methods are called.

- Define the various generic `_attribute` methods that you have declared

A minimal implementation could be:

    class Person
      include ActiveModel::AttributeMethods

      attribute_method_affix  :prefix => 'reset_', :suffix => '_to_default!'
      attribute_method_suffix '_contrived?'
      attribute_method_prefix 'clear_'
      define_attribute_methods ['name']

      attr_accessor :name

      private

      def attribute_contrived?(attr)
        true
      end

      def clear_attribute(attr)
        send("#{attr}=", nil)
      end

      def reset_attribute_to_default!(attr)
        send("#{attr}=", "Default Name")
      end
    end

Note that whenever you include ActiveModel::AttributeMethods in your class, it requires you to implement an `attributes` method which returns a hash with each attribute name in your model as hash key and the attribute value as hash value.

Hash keys must be strings.

### Constants

CALL_COMPILABLE_REGEXP
NAME_COMPILABLE_REGEXP

### Public Instance Methods

attribute_missing(match, *args, &block) click to toggle source

attribute_missing is like method_missing, but for attributes. When method_missing is called we check to see if there is a matching attribute method. If so, we call attribute_missing to dispatch the attribute. This method can be overloaded to customise the behaviour.

    # File lib/active_model/attribute_methods.rb, line 415
    def attribute_missing(match, *args, &block)
      __send__(match.target, match.attr_name, *args, &block)
    end

method_missing(method, *args, &block) click to toggle source

Allows access to the object attributes, which are held in the `@attributes` hash, as though they were first-class methods. So a Person class with a name attribute can use Person#name and Person#name= and never directly use the attributes hash -- except for multiple assigns with ActiveRecord#attributes=. A Milestone class can also ask Milestone#completed? to test that the completed attribute is not `nil` or 0.

It's also possible to instantiate related objects, so a Client class belonging to the clients table with a `master_id` foreign key can instantiate master through Client#master.

    # File lib/active_model/attribute_methods.rb, line 402
    def method_missing(method, *args, &block)
      if respond_to_without_attributes?(method, true)
        super
      else
        match = match_attribute_method?(method.to_s)
        match ? attribute_missing(match, *args, &block) : super
      end
    end

respond_to?(method, include_private_methods = false) click to toggle source

    # File lib/active_model/attribute_methods.rb, line 423
    def respond_to?(method, include_private_methods = false)
      if super
        true
      elsif !include_private_methods && super(method, true)
        # If we're here then we haven't found among non-private methods
        # but found among all methods. Which means that the given method is private.
        false
      else
        !match_attribute_method?(method.to_s).nil?
      end
    end

Also aliased as: respond_to_without_attributes?
respond_to_without_attributes?(method, include_private_methods = false) click to toggle source

A Person object with a name attribute can ask `person.respond_to?(:name)`, `person.respond_to?(:name=)`, and `person.respond_to?(:name?)` which will all return `true`.

Alias for: respond_to?

### Protected Instance Methods

attribute_method?(attr_name) click to toggle source

    # File lib/active_model/attribute_methods.rb, line 436
    def attribute_method?(attr_name)
      respond_to_without_attributes?(:attributes) && attributes.include?(attr_name)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.