Routing in Ruby on Rails is the backbone of any web application. It connects user requests (URLs) to the right controller actions (actions are the functions defined in controller file), which then render responses.

Here's a step-by-step guide to help you understand how to create routes in Rails with ease.

The routing system in Rails is powerful yet simple to understand, allowing you to create dynamic web apps easily.

1. Let's Start with Defining a Simple Route

Let’s start with a basic route. For example, if you want to map the URL /about to a PagesController with an about action, you’ll define it in config/routes.rb:

ruby
get 'about', to: 'pages#about'

Here, get specifies the HTTP method (GET request), 'about' is the URL path, and 'pages#about' refers to the controller and action. This means when a user visits /about, Rails will direct them to the about action in the PagesController.

2. RESTful Routes

One of Rails' best practices is to follow REST (Representational State Transfer). RESTful routes correspond to CRUD operations (Create, Read, Update, Delete) and are defined in a standard way. You can define RESTful routes using the resources method, which automatically creates routes for common actions like index, show, new, create, edit, update, and destroy.

Example for Post resource:

ruby
resources :posts

This one line generates all the essential routes for managing posts:

  • GET /posts – displays all posts (index)
  • GET /posts/:id – shows a single post (show)
  • GET /posts/new – displays form to create a new post (new)
  • POST /posts – handles the form submission (create)
  • GET /posts/:id/edit – displays form to edit a post (edit)
  • PATCH/PUT /posts/:id – updates an existing post (update)
  • DELETE /posts/:id – deletes a post (destroy)

3. Named Routes

Named routes make it easier to reference URLs in your app without hardcoding paths. You can assign a custom name using the as option. For example:

ruby
get 'contact', to: 'pages#contact', as: 'contact'

In your views, you can then use contact_path or contact_url instead of /contact.

ruby
<%= link_to "Contact Us", contact_path %>

This helps keep your code clean and maintainable, especially when URLs change later.

4. Nested Routes

When resources are related, you can nest them within one another. For example, if a post has many comments, it makes sense to define nested routes like this:

ruby
resources :posts do
  resources :comments
end

This generates routes for handling comments within the context of a post, like:

  • GET /posts/:post_id/comments – lists all comments for a post
  • POST /posts/:post_id/comments – creates a new comment on a post

5. Root Route

The root route defines the homepage of your app. Typically, you'd set it to a controller action that renders the main page:

ruby
root 'home#index'

Now, visiting the root URL (e.g., http://localhost:3000/) will load the index action of the HomeController.

6. Route Helpers

Rails automatically generates route helper methods based on your defined routes. For example, if you have resources :posts, Rails will create helper methods like posts_path (for index) and new_post_path (for new), making your code cleaner and easier to understand.

ruby
<%= link_to "All Posts", posts_path %>

7. Customizing Routes with Constraints

You can also add constraints to routes, such as limiting them to certain HTTP methods or formats. For example, to limit a route to JSON responses only:

ruby
get 'posts', to: 'posts#index', defaults: { format: 'json' }

Creating routes in Ruby on Rails is straightforward, and understanding how they work is important for building any web application.

Let me know the feedback in Comments below.

For more detailed information, check out the official Rails Routing Guide.

Comments(0)