Coding guidelines

Don’t store your customers’ phone, email, last name, street in plain text.

Never write a method nobody calls. Never rescue an error nobody has incurred.

Two calls on the same object in one expression are the tell: the second is unneeded.

Between two versions carrying the same meaning, always pick the shorter name.

claimed_by, matching — methods named like a query must not have any side effect.

Every method that can be private must be private.

Add a single-line comment above each class/constant/method that is not private.

Small commits with long descriptions (why the code was shipped) and linear history.

Full coverage and not one line more. Never test code you don’t own.

Don’t Titleize. It’s ZIP not Zip. It’s license not licence. Respect the apostrophes.

At most 100 lines in a file. At most 100 characters in a line. Comments count.

You don’t need Service.new.call(params). Any method call is a code smell.

Don’t interpolate method names at runtime. Don’t send. Don’t break the rules.

Ruby does not care what class an object belongs to. Embrace the freedom. 🦆

def foo(bar) opening with baz = bar.baz should have been foo(bar.baz).

Taking **attributes only to hand them to a method makes params hard to follow.

No need for attr_reader :foo if @foo can be used instead.

A method can only return in its first line of code before any work starts.

Omit on a call’s arguments; keep the inner ones where parsing needs them.

Enhance RuboCop for code that is easy to grep and clean to diff:

• Single quotes are the rule; double quotes only for interpolation and escape [1] [2]
• Trailing comma on the last line of multiline literals (closing brace on its line) [3] [4]
• when and else sit one level in from case and end [5]
• private sits with class; private methods are indented like public ones[6]

Extend with Concern, respect strong params, apply convention over configuration.

Embrace REST: endpoints are CRUD on resources. Add custom resources, never actions.

Build off the main branch of rails/rails. Scrap any ~> from your Gemfile.

Order gems alphabetically and document inline why the app would break without them.

Rails.cache wherever the same rows would be read or the same markup rendered.

Run tests with config.cache_store = :memory_store to verify caching works.

Don’t pass instance variables to partials—use strict <%# locals: ... %> instead.

Redirect out of the app with allow_other_host: true; after a non-GET with status: :see_other; break out of a frame with data: { turbo_frame: '_top' }.

Eager-load associations. Check if records exist and loop over them in a single query.

Avoid the cost of User.all if all you display is User.select(:name, :email).

Ensure every migration you write is reversible.

Use change before up/down. Use up_only before reversible { |dir| dir.up }.

Clarify a decimal column price stores money with attribute :price, :amount.

All you need is to register a new type: Amount < ActiveRecord::Type::Decimal.

Invoke encrypt on any sensitive data. Add deterministic: { fixed: false } to columns that must be queried or kept unique such as: User.find_by(email:).

PostgreSQL offers native types and extensions that play well with Rails:

• type: :citext to store case-insensitive strings such as emails
• array: true to store an array in a single column
• create_enum to declare enums backed by names, not integers