Using ActiveRecord::Base::Normalization we can specify unique normalization rules for model attributes. When an attribute is assigned or changed, normalization is applied, and the normalised value is stored in the database.

To enable records to be queried using unnormalized values, the normalization is also done to the matching keyword argument of query methods. These rules are applied during data assignment and updates, ensuring that data is stored in a consistent and standardized format in the database.

Before Rails 7.1, we could normalize attributes using before_save callback.

Before

class User < ApplicationRecord
  before_save :normalize_name, if name.present?

  private

  def normalize_name
    self.name = name.strip.titlecase
  end
end

With our own custom normalization, we cannot make queries using finder methods using unnormalized values.

After

class User < ActiveRecord::Base
  normalizes :name, with: -> name { name.strip.titlecase }
end

Thanks to this PR, in the above code, The normalizes method is used to define an attribute normalization rule for :name attribute of the User model, it strips leading,
and trailing spaces and converts the name to titlecase.

By default, Normalization will not be applied to nil values. To normalize nil value, we can enable it using :apply_to_nil option.

user = User.create(name: " JOHN DOE \n")
user.name # => "John Doe"

# This demonstrates that the name attribute is successfully normalized during the creation of a new user.

We can apply the normalization rule manually using the class method normalize_value_for.

User.normalize_value_for(:name, " JOHN DOE\n")
# => "John Doe"

Normalization is by default applied to the finder method. This allows a record to be created and later queried using unnormalized values but it won’t work with SQL fragments. Since SQL does not automatically apply the normalization rules defined in our model, it searches for an exact match.

# Finding a user by a differently formatted name:
user = User.find_by(name: "\tJOHN DOE ")
user.name # => "John Doe"
user.name_before_type_cast # => "John Doe"


# Counting users based on a differently formatted name:
User.where(name: "\t JOHN DOE ").count # => 1
User.where(["name = ?", "\tJOHN DOE "]).count # => 0


# Checking for the existence of a user with a differently formatted name:
User.exists?(name: "\tJOHN DOE ") # => true
User.exists?(["name = ?", "\tJOHN DOE "]) # => false

Normalization is not automatically applied when fetching data from the database to prevent unintended alterations to pre-existing records. To apply normalization to pre-existing data, we can either assign a new value to the attribute or explicitly migrate it using the Normalization#normalize_attribute method.

legacy_user = User.find(1)
legacy_user.name # => " JOHN DOE\n"
legacy_user.normalize_attribute(:name)
legacy_user.name # => "John Doe"
legacy_user.save