# module ActiveModel::AttributeMethods

## Active Model Attribute Methods¶ ↑

Provides a way to add prefixes and suffixes to your methods as well as handling the creation of `ActiveRecord::Base`-like class methods such as `table_name`.

The requirements to implement `ActiveModel::AttributeMethods` are to:

- `include ActiveModel::AttributeMethods` in your class.

- Call each of its methods 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.

- Define 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.

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

      def attributes
        { 'name' => @name }
      end

      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

### 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 tell `attribute_missing` to dispatch the attribute. This method can be overloaded to customize the behavior.

    # File lib/active_model/attribute_methods.rb, line 440
    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 hash returned by `attributes`, as though they were first-class methods. So a `Person` class with a `name` attribute can for example use `Person#name` and `Person#name=` and never directly use the attributes hash – except for multiple assignments with `ActiveRecord::Base#attributes=`.

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`.

Calls superclass method

    # File lib/active_model/attribute_methods.rb, line 427
    def method_missing(method, *args, &block)
      if respond_to_without_attributes?(method, true)
        super
      else
        match = matched_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
Calls superclass method

    # File lib/active_model/attribute_methods.rb, line 448
    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
        !matched_attribute_method(method.to_s).nil?
      end
    end

Also aliased as: respond_to_without_attributes?
respond_to_without_attributes?(method, include_private_methods = false)

A `Person` instance 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?

### Private Instance Methods

attribute_method?(attr_name) click to toggle source

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

matched_attribute_method(method_name) click to toggle source

Returns a struct representing the matching attribute method. The struct's attributes are prefix, base and suffix.

    # File lib/active_model/attribute_methods.rb, line 467
    def matched_attribute_method(method_name)
      matches = self.class.send(:attribute_method_matchers_matching, method_name)
      matches.detect { |match| attribute_method?(match.attr_name) }
    end

missing_attribute(attr_name, stack) click to toggle source

    # File lib/active_model/attribute_methods.rb, line 472
    def missing_attribute(attr_name, stack)
      raise ActiveModel::MissingAttributeError, "missing attribute: #{attr_name}", stack
    end