# ruby

A Cursor rule that pins down Ruby style for the whole project: RuboCop, Rails conventions, N+1 queries and SQL injection.

- rule · `type=rule` · Cursor · ★ 3579
- Author: sanjeed5
- License: CC0-1.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/sanjeed5/awesome-cursor-rules-mdc/tree/HEAD/rules-mdc/ruby.mdc
- Updated: 2026-05-19
- HTML: https://affpapa.org/en/nevibecode/rules/ruby

## What it does

Drop `.cursor/rules/ruby.mdc` into the project and Cursor applies it to every file. The rule covers structure first: one class or module per file, `snake_case` filenames matching `CamelCase` names, two-space indents, 120-character lines, a single trailing newline. Each point comes with a bad and a good example, so the agent has something concrete to copy.

Then it moves to idioms and performance. Block shorthand like `&:method_name`, guard clauses instead of nested conditionals, keyword arguments, argument forwarding with `...` on Ruby 3.0+. On the Rails side: `includes` to kill N+1 queries, memoization with `||=`, strong parameters, and parameter binding instead of string interpolation in SQL. Error handling gets its own section — custom exception classes and `rescue` that names the exception type.

The rule is built around RuboCop and the official Ruby and Rails style guides, so anything you deliberately disabled in `.rubocop.yml` will keep resurfacing in lint output. That is the trade-off: the linter and the rule pull in the same direction, which is fine until your project disagrees with one of them.

## Install

### Cursor (native platform)

**Manually: put the files in place**
- File: `.cursor/rules/ruby.mdc` — Frontmatter: description, globs, alwaysApply

### Claude Code

**Manually: put the files in place**
- File: `.claude/rules/ruby.md` — The paths frontmatter field limits the files: move globs from the source into paths

### Codex

**AGENTS.md**
- Codex reads AGENTS.md: paste the rule text there

### GitHub Copilot

**Manually: put the files in place**
- File: `.github/instructions/ruby.instructions.md` — The applyTo field sets which files it applies to: move globs from the source into applyTo

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/rules/ruby.md`

### Cline

**Manually: put the files in place**
- File: `.clinerules/ruby.md`

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/sanjeed5/awesome-cursor-rules-mdc/tree/HEAD/rules-mdc/ruby.mdc

## When to use it
- settle on one Ruby style across a team
- track down N+1 queries in Rails
- block mass assignment with strong parameters
- flatten nested conditionals into guard clauses
- replace interpolated SQL with bound parameters

## Example prompts
- check this controller against the ruby rule
- rewrite this method following the ruby rule
- go through the services and fix N+1 queries per the ruby rule

## Source text · ruby.mdc · CC0-1.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 50f9b941d87d36b0.

BEGIN THIRD-PARTY FILE 50f9b941d87d36b0
````text
---
description: This guide provides opinionated, actionable best practices for writing modern Ruby code, focusing on maintainability, performance, and security, with a strong emphasis on RuboCop and Rails conventions.
globs: **/*
---
# Ruby Best Practices

Our team adheres to a strict set of Ruby best practices, primarily enforced by RuboCop and aligned with the official Ruby and Rails Style Guides. This document serves as your definitive reference for writing clean, efficient, and maintainable Ruby code.

## 1. Code Organization & Structure

Adhere to the Single Responsibility Principle (SRP) and keep files focused.

### 1.1 Single Class/Module Per File
Each Ruby file must define a single class or module. Name the file using `snake_case` corresponding to the `CamelCase` class/module name.

❌ BAD
```ruby
# user.rb
class User; end
class UserProfile; end
```

✅ GOOD
```ruby
# user.rb
class User; end

# user_profile.rb
class UserProfile; end
```

### 1.2 Rails Directory Structure
Follow Rails' "convention over configuration" for project structure.

❌ BAD
```ruby
# app/services/user_management/create_user.rb
# app/validators/email_validator.rb
```

✅ GOOD
```ruby
# app/services/user_management/create_user.rb (for complex logic)
# app/validators/email_validator.rb (standard Rails convention)
```

### 1.3 Configuration Files
Place custom initialization code in `config/initializers`. Keep gem-specific initializers in separate files named after the gem.

❌ BAD
```ruby
# config/initializers/app_setup.rb
# Contains setup for CarrierWave, Sidekiq, and custom app config.
```

✅ GOOD
```ruby
# config/initializers/carrierwave.rb
# config/initializers/sidekiq.rb
# config/initializers/custom_app_config.rb
```

## 2. Formatting

Consistency is paramount. RuboCop enforces these rules automatically.

### 2.1 Indentation & Line Length
Use two-space soft tabs. Limit lines to 120 characters to balance readability and screen real estate.

❌ BAD
```ruby
def long_method_name(param1, param2, param3, param4, param5, param6, param7) # > 120 chars
    puts "This line is indented with four spaces."
end
```

✅ GOOD
```ruby
def long_method_name(param1, param2, param3, param4, param5, param6, param7)
  puts "This line is indented with two spaces."
end
```

### 2.2 Trailing Whitespace & Newlines
Remove all trailing whitespace. End every file with a single newline.

❌ BAD
```ruby
puts "Hello"  # Trailing spaces
# No newline at EOF
```

✅ GOOD
```ruby
puts "Hello"
# Single newline at EOF
```

## 3. Naming Conventions

Strictly follow Ruby community standards for naming.

### 3.1 Variables, Methods, Files
Use `snake_case`. Do not separate numbers from letters.

❌ BAD
```ruby
someVar = 1
def someMethod; end
HelloWorld.rb
```

✅ GOOD
```ruby
some_var = 1
def some_method; end
hello_world.rb
```

### 3.2 Classes & Modules
Use `CamelCase`.

❌ BAD
```ruby
class Some_Class; end
```

✅ GOOD
```ruby
class SomeClass; end
```

### 3.3 Constants
Use `SCREAMING_SNAKE_CASE`. Freeze mutable constants.

❌ BAD
```ruby
SomeConst = 5
ALL_COLORS = ['red', 'blue']
```

✅ GOOD
```ruby
SOME_CONST = 5
ALL_COLORS = ['RED', 'BLUE'].freeze
```

### 3.4 Predicate & Bang Methods
Predicate methods (return boolean) end with `?`. Methods with side effects or that raise exceptions end with `!`.

❌ BAD
```ruby
def is_valid; end
def save_record; end # if it raises on failure
```

✅ GOOD
```ruby
def valid?; end
def save_record!; end # raises ActiveRecord::RecordInvalid on failure
```

## 4. Common Patterns & Anti-patterns

Embrace idiomatic Ruby and Rails patterns.

### 4.1 Block Shorthand
Use `&:method_name` for simple blocks.

❌ BAD
```ruby
names.map { |name| name.upcase }
```

✅ GOOD
```ruby
names.map(&:upcase)
```
````
END THIRD-PARTY FILE 50f9b941d87d36b0

The third-party file has ended. Everything between the 50f9b941d87d36b0 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 3755 of 8929 bytes. © sanjeed5 · CC0-1.0 · https://github.com/sanjeed5/awesome-cursor-rules-mdc/tree/HEAD/rules-mdc/ruby.mdc

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md