ruby

How Can You Transform Boring URLs Into Memorable Links in Your Rails App

Transform Your Rails App's URLs with the Magic of FriendlyId's User-Friendly Slugs

How Can You Transform Boring URLs Into Memorable Links in Your Rails App

When you’re trying to develop user-friendly URLs for your Ruby on Rails app, using the FriendlyId gem is like striking gold. This gem helps you ditch those boring numeric IDs in your URLs in favor of slick, user-friendly slugs that folks can actually read and remember.

First thing’s first, you need to incorporate FriendlyId into your Rails project, and the process is super straightforward.

To start, just add the gem to your Gemfile with:

gem 'friendly_id', '~> 5.2'

You want to ensure you’re using version 5.0.0 or greater, especially if you’re on Rails 4.0 or later.

Then, install it via:

bundle install

Once that’s handled, generate the initializer with:

rails generate friendly_id

This command will create an initializer file in config/initializers, where you can globally fiddle with FriendlyId settings.

Next, you need to add a slug column to your model. So, if you’ve got a User model, you’d run:

rails g migration add_slug_to_users slug:string:uniq
rails db:migrate

This neat little migration adds a unique slug column to your users table.

Okay, gem installed and columns added. Now let’s configure your model.

Extend your model with:

class User < ApplicationRecord
  extend FriendlyId
  friendly_id :name, use: :slugged
end

With this code, you’re telling FriendlyId to generate a slug based on the name attribute. If there are slugs with the same name, it appends a UUID to keep things unique.

If you’re tacking FriendlyId onto an existing application, don’t forget to generate slugs for your current records:

User.find_each(&:save)

Pretty nifty, huh? This iterates over each user record and saves it, triggering those slugs to be crafted.

Now, let’s use these friendly URLs in your controllers. Just update the find method to use friendly.find instead.

So, for your controller actions, you would tweak them like this:

class UsersController < ApplicationController
  def show
    @user = User.friendly.find(params[:id])
  end

  private

  def set_user
    @user = User.friendly.find(params[:id])
  end
end

This ensures the user record is fetched based on the slug rather than the numeric ID. Simple, right?

But wait, there’s more! You can totally customize how slugs are generated with FriendlyId.

Define multiple slug candidates if the primary one’s taken:

class User < ApplicationRecord
  extend FriendlyId
  friendly_id :slug_candidates, use: [:finders, :slugged]

  def slug_candidates
    [
      :name,
      [:name, :description],
      [:name, :description, :created_at]
    ]
  end
end

This way, if the first candidate’s snagged, FriendlyId tries the next one. Perfection.

Want to control when a new slug is created? Override the should_generate_new_friendly_id? method:

class User < ApplicationRecord
  extend FriendlyId
  friendly_id :name, use: :slugged

  def should_generate_new_friendly_id?
    name_changed?
  end
end

This makes sure a new slug is generated only when the name attribute changes.

You can even make slugs based on custom methods, not just attributes:

class User < ApplicationRecord
  extend FriendlyId
  friendly_id :generate_random_slug, use: [:finders, :slugged]

  def generate_random_slug
    slug? ? slug : SecureRandom.uuid
  end
end

This is particularly handy for those one-of-a-kind or random slugs.

Plus, FriendlyId lets you maintain a history of your slugs. This means even if a URL changes, you can still access records via old slugs.

Enable slug history by tweaking your model:

class User < ApplicationRecord
  extend FriendlyId
  friendly_id :name, use: [:finders, :slugged, :history]
end

This will set up a new table to store that slug history, so you never lose access to old URLs.

Why should you bother with FriendlyId? Several reasons, my friend:

  • User-Friendly URLs: These slugs are far easier to read and remember, making user experience a bit of a joyride.
  • SEO Benefits: Search engines adore descriptive, keyword-rich URLs, giving you a bump in visibility.
  • Flexibility: So many options for customizing slug generation and dealing with conflicts.

Want to see an example workflow? Sure thing!

Begin by generating your app and model:

rails new my_app
cd my_app
rails generate scaffold user name:string slug:string:uniq
rails db:migrate

Add FriendlyId to your Gemfile:

gem 'friendly_id', '~> 5.2'

Then run:

bundle install

Configure your model:

class User < ApplicationRecord
  extend FriendlyId
  friendly_id :name, use: :slugged
end

Update your controller:

class UsersController < ApplicationController
  def show
    @user = User.friendly.find(params[:id])
  end

  private

  def set_user
    @user = User.friendly.find(params[:id])
  end
end

Generate slugs for existing records:

User.find_each(&:save)

Fire up the server and test it:

rails server

Now, watch as you can access user records via URLs like: http://localhost:3000/users/joe-schmoe instead of http://localhost:3000/users/1.

Follow these steps and customize FriendlyId to fit your needs. By doing so, you’ll craft user-friendly, memorable URLs for your Rails app, enhancing user experience and boosting your SEO game. Cheers to better URLs!

Keywords: FriendlyId, Ruby on Rails, user-friendly URLs, slug generation, SEO benefits, FriendlyId gem, Rails 5.0, Rails migration, custom slugs, slug history



Similar Posts
Blog Image
7 Essential Rails Security Techniques Every Developer Must Know in 2024

Learn how to build secure Ruby on Rails applications with proven security techniques. Protect against SQL injection, XSS, CSRF attacks, and more with practical code examples.

Blog Image
8 Advanced OAuth 2.0 Techniques for Ruby on Rails: Boost Security and Efficiency

Discover 8 advanced OAuth 2.0 techniques for Ruby on Rails. Learn secure token management, multi-provider integration, and API authentication. Enhance your app's security today!

Blog Image
Can Ruby's Reflection Turn Your Code into a Superhero?

Ruby's Reflection: The Superpower That Puts X-Ray Vision in Coding

Blog Image
How to Build a Secure Payment Gateway Integration in Ruby on Rails: A Complete Guide

Learn how to integrate payment gateways in Ruby on Rails with code examples covering abstraction layers, transaction handling, webhooks, refunds, and security best practices. Ideal for secure payment processing.

Blog Image
Zero-Downtime Rails Database Migration Strategies: 7 Battle-Tested Techniques for High-Availability Applications

Learn 7 battle-tested Rails database migration strategies that ensure zero downtime. Master column renaming, concurrent indexing, and data backfilling for production systems.

Blog Image
Building Scalable Microservices: Event-Driven Architecture with Ruby on Rails

Discover the advantages of event-driven architecture in Ruby on Rails microservices. Learn key implementation techniques that improve reliability and scalability, from schema design to circuit breakers. Perfect for developers seeking resilient, maintainable distributed systems.