Ruby-On-Rails

# Ruby on Rails

General Guidelines

- Follow the RuboCop Style Guide and use tools like `rubocop`, `standardrb`, or `rufo` for consistent formatting.

- Use snake_case for variables/methods and CamelCase for classes/modules.

- Keep methods short and focused; use early returns, guard clauses, and private methods to reduce complexity.

- Favor meaningful names over short or generic ones.

- Comment only when necessary — avoid explaining the obvious.

- Apply the Single Responsibility Principle to classes, methods, and modules.

- Prefer composition over inheritance; extract reusable logic into modules or services.

- Keep controllers thin — move business logic into models, services, or command/query objects.

- Apply the “fat model, skinny controller” pattern thoughtfully and with clean abstractions.

- Extract business logic into service objects for reusability and testability.

- Use partials or view components to reduce duplication and simplify views.

- Use `unless` for negative conditions, but avoid it with `else` for clarity.

- Avoid deeply nested conditionals — favor guard clauses and method extractions.

- Use safe navigation (`&.`) instead of multiple `nil` checks.

- Prefer `.present?`, `.blank?`, and `.any?` over manual nil/empty checks.

- Follow RESTful conventions in routing and controller actions.

- Use Rails generators to scaffold resources consistently.

- Use strong parameters to whitelist attributes securely.

- Prefer enums and typed attributes for better model clarity and validations.

- Keep migrations database-agnostic; avoid raw SQL when possible.

- Always add indexes for foreign keys and frequently queried columns.

- Define `null: false` and `unique: true` at the DB level, not just in models.

- Use `find_each` for iterating over large datasets to reduce memory usage.

- Scope queries in models or use query objects for clarity and reuse.

- Use `before_action` callbacks sparingly — avoid business logic in them.

- Use `Rails.cache` to store expensive computations or frequently accessed data.

- Construct file paths with `Rails.root.join(...)` instead of hardcoding.

- Use `class_name` and `foreign_key` in associations for explicit relationships.

- Keep secrets and config out of the codebase using `Rails.application.credentials` or ENV variables.

- Write isolated unit tests for models, services, and helpers.

- Cover end-to-end logic with request/system tests.

- Use background jobs (ActiveJob) for non-blocking operations like sending emails or calling APIs.

- Use `FactoryBot` (RSpec) or fixtures (Minitest) to set up test data cleanly.

- Avoid using `puts` — debug with `byebug`, `pry`, or logger utilities.

- Document complex code paths and methods with YARD or RDoc.

App Directory Structure

- Define service objects in the `app/services` directory to encapsulate business logic.

- Use form objects located in `app/forms` to manage validation and submission logic.

- Implement JSON serializers in the `app/serializers` directory to format API responses.

- Define authorization policies in `app/policies` to control user access to resources.

- Structure the GraphQL API by organizing schemas, queries, and mutations inside `app/graphql`.

- Create custom validators in `app/validators` to enforce specialized validation logic.

- Isolate and encapsulate complex ActiveRecord queries in `app/queries` for better reuse and testability.

- Define custom data types and coercion logic in the `app/types` directory to extend or override ActiveModel type behavior.

Commands

- Use `rails generate` to create new models, controllers, and migrations.

- Use `rails db:migrate` to apply database migrations.

- Use `rails db:seed` to populate the database with initial data.

- Use `rails db:rollback` to revert the last migration.

- Use `rails console` to interact with the Rails application in a REPL environment.

- Use `rails server` to start the development server.

- Use `rails test` to run the test suite.

- Use `rails routes` to list all defined route