**Course Title:** Mastering Ruby on Rails: Building Scalable Web Applications **Section Title:** Working with Databases and Active Record **Topic:** Implementing validations and callbacks in models In the previous topics, we explored how to work with databases and Active Record in Rails. However, to ensure data consistency and integrity, we need to validate and transform data before saving it to the database. In this topic, we will learn about implementing validations and callbacks in models using Rails. ### What are Validations in Rails? Validations are used to ensure that only valid data is saved to the database. They are defined at the model level and are typically used to enforce business rules, such as: * Ensuring that a user's email address is in the correct format * Ensuring that a product's price is greater than zero * Ensuring that a phone number is in the correct format Rails provides several built-in validation methods that can be used to validate attributes in a model. These methods include: * `validates` * `validates!` * `validate` ### Common Validation Methods Here are some common validation methods used in Rails: * `presence`: Ensures that the attribute is present. * `length`: Ensures that the attribute has a specific length. * `format`: Ensures that the attribute matches a specific format. * `inclusion`: Ensures that the attribute is included in a list of values. * `exclusion`: Ensures that the attribute is not included in a list of values. * `numericality`: Ensures that the attribute is a number. Example: ```ruby class User < ApplicationRecord validates :name, presence: true validates :email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i } validates :age, numericality: { greater_than: 18 } end ``` In this example, we are validating the `name`, `email`, and `age` attributes in the `User` model. The `validates` method is used to define the validation rules. ### Custom Validation Methods In addition to the built-in validation methods, you can also define custom validation methods in your model. Custom validation methods are useful when you need to validate data that doesn't fit into one of the built-in validation categories. Example: ```ruby class User < ApplicationRecord validate :password_complexity private def password_complexity return if password.blank? if password.length < 8 errors.add(:password, "must be at least 8 characters long") end unless password.match?(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)./) errors.add(:password, "must include at least one uppercase letter, one lowercase letter, and one digit") end end end ``` In this example, we define a custom validation method called `password_complexity` that checks the password attribute for a minimum length and a mix of uppercase and lowercase letters. ### Callbacks in Rails Callbacks are methods that are triggered at specific points in the lifecycle of a model. They are used to perform actions such as: * Sending a confirmation email after a user creates an account * Updating a related model after a record is saved * Logging activity after a record is updated Rails provides several built-in callbacks that can be used in models. These callbacks include: * `before_create` * `after_create` * `before_update` * `after_update` * `before_destroy` * `after_destroy` Example: ```ruby class User < ApplicationRecord before_create :send_confirmation_email private def send_confirmation_email # Send confirmation email implementation end end ``` In this example, we define a before-create callback that sends a confirmation email after a user creates an account. **Key Concepts:** * Validations: used to ensure data consistency and integrity * Callbacks: used to perform actions at specific points in the lifecycle of a model * Built-in validation methods: `presence`, `length`, `format`, `inclusion`, `exclusion`, `numericality` * Custom validation methods: can be defined to validate data that doesn't fit into built-in categories * Built-in callbacks: `before_create`, `after_create`, `before_update`, `after_update`, `before_destroy`, `after_destroy` **Practical Takeaways:** * Use validations to ensure data consistency and integrity * Use callbacks to perform actions at specific points in the lifecycle of a model * Keep validation and callback logic organized and maintainable **Additional Resources:** * [Ruby on Rails Guides: Validations and Callbacks](https://guides.rubyonrails.org/v7.0/active_record_validations.html) * [Ruby on Rails API: Validation](https://api.rubyonrails.org/v7.0.0/classes/ActiveModel/Validations/HelperMethods.html) * [Ruby on Rails API: Callbacks](https://api.rubyonrails.org/v7.0.0/classes/ActiveRecord/Callbacks.html) **What's Next?** In the next topic, we will learn about implementing user authentication using Devise or similar gems. **Have any questions or need help?** If you have any questions or need help with implementing validations and callbacks in your Rails application, please leave a comment below.