Smart page titles in Ruby on Rails

Having separate titles for each page in Rails application is a very common requirement and yet RoR does not provide any built in ways to deal with it. I am going to present you with some handy code that can solve this problem without use of gems.

There are going to be 3 ways to define a page title:

  • For tho whole controller.
  • For a specific action inside a controller.
  • Implicitly from a controller name.
Last is gonna be especially useful, you can just drop the following code into your application and have reasonably good titles.

So lets add code to our parent ApplicationController:

class ApplicationController < ActionController::Base
before_filter :set_page_title
CONTROLLER_TITLES = Hash.new
# for setting page titles for the whole controller
def self.page_title title
CONTROLLER_TITLES[self.name] = title
end
# for setting page titles for a specific actions.
# this overrides @page_title previously set in before_filter
def page_title title
@page_title = title
end
private
def set_page_title
@page_title = CONTROLLER_TITLES[self.class.name] || controller_implicit_title
end
def controller_implicit_title
@@controller_implicit_titles ||= Hash.new
# remove any namespaces and mentions of controller
# so Client::OrdersController becomes "Orders"
@@controller_implicit_titles[self.class.name] ||= (self.class.name.gsub(/(.+::)/, '').gsub('Controller', '').underscore.gsub('_', ' ').titleize
end
end
view raw application_controller.rb hosted with ❤ by GitHub

And reference page title in our layout:

<!DOCTYPE html>
<html>
<head>
<title><%= @page_title || 'My Awesome App'%></title>
</head>
<body>
<%= yield %>
</body>
view raw application_layout.html.erb hosted with ❤ by GitHub

After that setting pages titles is extremely easy. You don't even have to do it if you are naming your controllers properly.

class OrdersController < ApplicationController
page_title 'Orders' # unless specified otherwise all pages are gonna have title 'Orders"
def index # Page title == 'Orders'
@orders = Order.all
end
def cancelled # Page title == 'Cancelled Orders'
page_title 'Cancelled Orders'
@orders = Order.cancelled
end
end
view raw orders_controller.rb hosted with ❤ by GitHub
class OrderNotesController < ApplicationController
def index # Page title == 'Order Notes'
@note = OrderNote.all
end
def order # Page title == 'Notes for Order #12345'
page_title = "Notes for Order ##{params[:order_id]}"
@note = OrderNote.where(order_id: params[:order_id])
end
end
view raw order_notes_controller.rb hosted with ❤ by GitHub

Popular posts from this blog

HTTP server in Ruby 3 - Fibers & Ractors

Image
This is part #2. Head over to part #1 to learn about HTTP in Ruby. Motivation Historically Ruby's been lacking in the concurrency department. Ruby has "native" threads (prior to 1.9 there were only "green"), which means there can be multiple threads controlled by an OS, but only 1 thread can be executed at a time, this is managed via Global Interpreter Lock (GIL). However, native calls and I/O calls can be executed in parallel. During an I/O call, a thread gives up control and waits for a signal that the I/O has finished. This means I/O heavy applications can benefit from multiple threads. In this article we are going to explore different concurrency modes for our HTTP server: Single-threaded Multi-threaded Fibers Ractors Single-threaded Let's start simple and see how a single threaded HTTP server could look like ( full code ): def start socket = TCPServer.new(HOST, PORT) sock...
Read more

Migration locks for TypeORM

Image
Schema migrations is a must-have functionality for any DB framework. TypeORM provides decent utilities for dealing with migrations, however having a decade of experience in Ruby on Rails I got really spoiled and take some features for granted. One of these features is locking a database while a migration going on so 2 processes running concurrently don't step on each other's toes. This is also important when you run migrations in Kubernetes before launching your app. I was really surprised to find out that this basic feature is not supported , so decided to implement it on my own. Implementation // typeormMigrationUtils.ts import { Connection, createConnection } from 'typeorm' import config from '../ormconfig' import CRC32 from 'crc-32' const MIGRATOR_SALT = 2053462845 async function withAdvisoryLock( connection: Connection, callback: () => Promise<void> ): Promise<boolean> { // generate a unique lock...
Read more

Turbocharge HTTP requests in Ruby

Image
The problem The slowest part in many applications is I/O, especially network I/O. We spend a lot of trying to make sure we reduce the number of calls and cache results of API calls to 3rd party services and resources. Imagine we want to get data from Rick and Morty API . In this article, we are going to speed up subsequent requests to this API by almost 4x times . The solution And yet there's a trick that even very senior developers and popular API library/clients forget about that can shave off precious time of your network calls built right into HTTP. Establishing an HTTP connection is very costly, especially if it uses TLS . This is a fixed price added to your HTTP calls that can be avoided by using keep-alive - a mechanism built into HTTP. According to Wiki : HTTP keep-alive, or HTTP connection reuse, is the idea of using a single TCP connection to send and receive multiple HTTP requests/responses, as opposed to opening a new connection...
Read more