This page will age badly, since Cursor did already move to another .rules directory structure.

However, in the past few months, my hobby usage of rails has been more and more efficient.

First, I really enjoyed the novelties of Rails 8 and the kamal chain of deployment. It really suits my usage: being able to push a few lines of code and forget about it for weeks (months, years ?).

Then, I found that the most repetitive things of the framework were surprisingly well supported by LLMs, especially Claude 3.5 acting with Cursor Composer.

If you're starting with Cursor but already have some rails basics, I'm happy to share this .cursorrules files. I found 98% of it on X and other sources, thanks to the community. I am not taking any credit for this file -- only sharing for the shake of helping others iterate and improve!

You are an expert in Ruby on Rails, Hotwire (Turbo and Stimulus), and Tailwind CSS.

## Project

- Name: "<PROJECT NAME>"
- Description: "<SMALL DESCRIPTION OF THE PROJECT>"
- How to interact with me:
  1. Always think step by step and explain your thoughts before writing code
  2. Re-think the problem and the solution before writing code. Never write code that could be handled by the framework or its gems (ie: pagination, sorting, etc.)
  3. Always consider the overall architecture and design of the application.
  4. Make sure to create documentation for all new code.

## Languages and frameworks

- Ruby
- Rails 8
- Hotwire (Turbo and Stimulus)
- Tailwind CSS
- Use hotwire for all dynamic interactions.
- Use tailwind css for styling.
- Use stimulus for all dynamic interactions.
- Use turbo for all page transitions.
- Use turbo-rails to ease the use of turbo in the application.

## Locales

- en-US for all code, comments, naming and documentation, rake tasks, logging, etc.
- fr-FR for all user-facing text on the website.

## Code Style and Structure

- Write concise, idiomatic Ruby code with accurate examples.
- Follow Rails conventions and best practices.
- Use object-oriented and functional programming patterns as appropriate.
- Prefer iteration and modularization over code duplication.
- Use descriptive variable and method names (e.g., user_signed_in?, calculate_total).
- Structure files according to Rails conventions (MVC, concerns, helpers, etc.).
- Write code that is easy to understand.
- Write code that is easy to maintain.
- Make rubocop happy.
- Write code that would make DHH proud.

## Naming Conventions

- Use snake_case for file names, method names, and variables.
- Use CamelCase for class and module names.
- Follow Rails naming conventions for models, controllers, and views.

## Ruby and Rails Usage

- Use Ruby 3.x features when appropriate (e.g., pattern matching, endless methods).
- Leverage Rails' built-in helpers and methods.
- Use ActiveRecord effectively for database operations.

## Syntax and Formatting

- Follow the Ruby Style Guide (https://rubystyle.guide/)
- Use Ruby's expressive syntax (e.g., unless, ||=, &.)
- Prefer single quotes for strings unless interpolation is needed.

## Error Handling and Validation

- Use exceptions for exceptional cases, not for control flow.
- Implement proper error logging and user-friendly messages.
- Use ActiveModel validations in models.
- Handle errors gracefully in controllers and display appropriate flash messages.

## UI and Styling

- Use Hotwire (Turbo and Stimulus) for dynamic, SPA-like interactions.
- Implement responsive design with Tailwind CSS.
- Use Rails view helpers and partials to keep views DRY.

## Performance Optimization

- Use database indexing effectively.
- Implement caching strategies (fragment caching, Russian Doll caching).
- Use eager loading to avoid N+1 queries.
- Optimize database queries using includes, joins, or select.

## Key Conventions

- Follow RESTful routing conventions.
- Use concerns for shared behavior across models or controllers.
- Implement service objects for complex business logic.
- Use background jobs (e.g., Sidekiq) for time-consuming tasks.

## Testing

- Write comprehensive tests using RSpec or Minitest.
- Follow TDD/BDD practices.
- Use factories (FactoryBot) for test data generation.

## Security

- Implement proper authentication and authorization (e.g., Devise, Pundit).
- Use strong parameters in controllers.
- Protect against common web vulnerabilities (XSS, CSRF, SQL injection).

## Ruby on Rails

- Follow the official Ruby on Rails guides for best practices in routing, controllers, models, views, and other Rails components.