Class names are CamelCase
.
Methods and variables are snake_case
.
Methods with a ?
suffix will return a boolean.
Methods with a !
suffix mean one of two things: either the method operates destructively in some fashion, or it will raise and exception instead of failing (such as Rails models' #save!
vs. #save
).
In documentation, ::method_name
denotes a class method, while #method_name
denotes a instance method.
Database tables use snake_case
. Table names are plural.
Column names in the database use snake_case
, but are generally singular.
Example:
+--------------------------+
| bigfoot_sightings |
+------------+-------------+
| id | ID |
| sighted_at | DATETIME |
| location | STRING |
| profile_id | FOREIGN KEY |
+------------+-------------+
+------------------------------+
| profiles |
+---------------------+--------+
| id | ID |
| name | STRING |
| years_of_experience | INT |
+---------------------+--------+
Model class names use CamelCase
. These are singular, and will map automatically to the plural database table name.
Model attributes and methods use snake_case
and match the column names in the database.
Model files go in app/models/#{singular_model_name}.rb
.
Example:
# app/models/bigfoot_sighting.rb
class BigfootSighting < ActiveRecord::Base
# This class will have these attributes: id, sighted_at, location
end
# app/models/profile.rb
class Profile < ActiveRecord::Base
# Methods follow the same conventions as attributes
def veteran_hunter?
years_of_experience > 2
end
end
Relations use snake_case
and follow the type of relation, so has_one
and belongs_to
are singular while has_many
is plural.
Rails expects foreign keys in the database to have an _id
suffix, and will map relations to those keys automatically if the names line up.
Example:
# app/models/bigfoot_sighting.rb
class BigfootSighting < ActiveRecord::Base
# This knows to use the profile_id field in the database
belongs_to :profile
end
# app/models/profile.rb
class Profile < ActiveRecord::Base
# This knows to look at the BigfootSighting class and find the foreign key in that table
has_many :bigfoot_sightings
end
Controller class names use CamelCase
and have Controller
as a suffix. The Controller
suffix is always singular. The name of the resource is usually plural.
Controller actions use snake_case
and usually match the standard route names Rails defines (index
, show
, new
, create
, edit
, update
, delete
).
Controller files go in app/controllers/#{resource_name}_controller.rb
.
Example:
# app/controllers/bigfoot_sightings_controller.rb
BigfootSightingsController < ApplicationController
def index
# ...
end
def show
# ...
end
# etc
end
# app/controllers/profiles_controller.rb
ProfilesController < ApplicationController
def show
# ...
end
# etc
end
Route names are snake_case
, and usually match the controller. Most of the time routes are plural and use the plural resources
.
Singular routes are a special case. These use the singular resource
and a singular resource name. However, they still map to a plural controller by default!
Example:
resources :bigfoot_sightings
# Users can only see their own profiles, so we'll use `/profile` instead
# of putting an id in the URL.
resource :profile
View file names, by default, match the controller and action that they are tied to.
Views go in app/views/#{resource_name}/#{action_name}.html.erb
.
Examples:
app/views/bigfoot_sightings/index.html.erb
app/views/bigfoot_sightings/show.html.erb
app/views/profile/show.html.erb
@Fermn
rails new
takes a path for the app files and will convert that into camel case for you. Most of the rails generators are smart about converting between snake case and camel case as needed.