Archive

Docked Rails: Setup a Ruby on Rails Application on Docker 🐳

Setting up a new Ruby on Rails application with all the dependencies doesn't have to be complicated. Docked is a new command line tool that simplifies the process of creating a new Rails app using Docker.

Nested Modules in Ruby

Ruby provides two different ways to define nested modules. This post explains the difference between them and how to decide which one to use. It also explains the `Module.nesting` method which returns the list of modules nested when called.

The Difference Between load, autoload, require, and require_relative in Ruby 📖

Loading external files can get tricky in Ruby, but it doesn't have to be. This post explains the usage of Ruby's load, require, and require_relative methods, and when to use each.

Open GitHub Repositories in VS Code In-Browser

GitHub allows you to open any repository in an in-browser VS Code by just pressing the `.` key on your keyboard.

Method Shorthand in Ruby

While reading the docs, I learned that Ruby (3.0 and up) provides a shorthand syntax for one-line methods, similar to computed properties in C#. Personally, I don't plan to use them in my code, except in tests. I prefer the standard syntax. The shorthand also looks confusing with the

📖 Understanding the Instrumentation API in Rails

The instrumentation API in ActiveSupport serves a dual purpose. You can use it to implement the publish-subscribe pattern, as well as benchmark how long it took to execute some action.

Array Inquiry in Rails

The ArrayInquirer class provided by the Active Support framework in Rails provides a readable way to check the contents of an array. This post explores how you can implement this using metaprogramming in Ruby.

Tracking TODO and FIXME Comments with Rails Notes Command

This post shows how you can use the notes command in Rails to search through your codebase for comments starting with a specific keyword. By default, it searches the codebase for FIXME, OPTIMIZE, and TODO comments, but you can also configure it to use custom keywords.

What Happens When You Call render? Let's Understand the Rails Rendering Process

This article explains the Rails rendering process in the context of returning JSON data from the controller. Hopefully, it will make it clear what really happens when you call the render method from the controller.

Regular Expressions in Ruby

Regular expressions can be both terribly awkward and extremely useful. In this introductory post, we will learn the basics of regular expressions in Ruby programming language and how to use them for routine programming tasks.

The Rails Config File

You must have used a ~/.bashrc or ~/.zshrc file to configure your environment. Did you know Ruby on Rails has a ~/.railsrc file that configures your Rails applications?

Let's Learn Ruby on Rails + Hotwire by Building a To-Do List

In this article, we'll learn Ruby on Rails and Hotwire by building a to-do list from scratch. It shows how to build single-page web applications using traditional web architecture (server-rendered HTML), without the complexity of modern JavaScript frameworks like React.

Hiding Sensitive Information from Logs Using Parameter Filtering in Rails

This article explains why you shouldn't log confidential or user-identifiable information and how to filter it using parameter filtering in Rails. We'll also learn how Rails implements this feature internally.

A Brief Introduction to Rails Initializers

After loading the framework and any gems in your application, Rails runs the initializers under the `config/initializers` directory. This article explains how initializers work and how they're implemented.

Building a Web Application Without Rails: Rendering Views Dynamically using ERB

This is the fourth article in the series on building awesome web applications with Ruby and Rails. We continue our journey to build a web application without using Rails to better understand how Rails works. Today, we'll learn how to render views dynamically with the ERB gem used by Rails.

How self Keyword Works in Ruby

Ruby's self keyword can be pretty confusing to understand, especially if you're new to Ruby. Not understanding it often leads to subtle programming bugs that can be difficult to debug. This post explains how it works under common, everyday situations.

Can You Build a Web Application in Ruby Without Rails? Yes, You Can!

This is the third article in the series on building awesome web applications with Rails. It shows how to build a simple web app in Ruby from scratch, without using Rails.

Difference Between the Length, Size, and Count Methods in Rails

You can use the length, size, and count methods to find the number of elements in a collection. This post explores the difference between these methods and explains how you should choose which method to use according to your situation.

Setting Up Development Environment for Rails

This is the second article in the series on building awesome web applications with Ruby on Rails. It shows how to set up a kick-ass development environment for building Rails apps.

Define New Routes Using the Member and Collection Blocks

This post shows how to define new routes using the member and collection blocks provided by the Rails router.

How &:method Shortcut Works in Ruby

This post shows you how Ruby's `&:method` shortcut works behind the scenes. It's a clever trick that was added first in ActiveSupport and became an official feature in Ruby 1.8.7.

Building Web Applications with Ruby on Rails

This is the first article in the series on building awesome web applications with Ruby on Rails. It explores why you should build for the web and use a web framework, especially Rails.

Understanding Blocks and the Difference in Proc and Lambda

If you've been programming in Ruby for a while, you've definitely come across blocks or one of their flavors via a Proc or lambda. Though they seem confusing, they're not that difficult to understand. This blog post explains the concept of blocks and the differences between Proc and lambda. Blocks

The Definitive Guide to Rack for Rails Developers

This article explains pretty much everything you need to know about Rack as a Ruby and Rails developer. We will start with the basics and move to more advanced concepts like middleware and the Rack DSL.

Compare Strings Using Inquiry

Similar to the ArrayInquirer class, which tests if an array contains a value, the ActiveSupport::StringInquirer class provides a nice way to compare two strings. Use it when you have an internal method that returns a string, and the consumer of that method needs to compare it with another string.

How to Access a Hash with both String and Symbol Keys in Rails

Sometimes, you receive a hash key as a method parameter or via user input, and you want to make your hash understand that key as-is, without worrying if it's a string or a symbol. A good example is the params hash in Rails. You can access it using either a

How to Compress a String in Ruby (and Rails)

You can compress large strings using the Zlib module provided by Ruby's standard library.

Configure Classes Using the Configurable Concern in Rails

Sometimes, you need a config-like property on a class, such as a logger. Rails provides the Configurable concern that lets you accomplish this. It provides a config method that allows you to access (read and write) configuration options using the method-like syntax. class Invoice include ActiveSupport::Configurable config_accessor :type

Concerns in Rails: Everything You Need to Know

Concerns are an important concept in Rails that can be confusing to understand for those new to Rails as well as seasoned practitioners. This post explains why we need concerns, how they work, and how to use them to simplify your code.

How to Access Variables Outside Scopes in Ruby

In C# and Java, variables from the outer scope are visible to the inner scope. In Ruby, scopes are sharply separated, and nested visibility is not allowed. As soon as the control enters a new scope, i.e. a class, module, or a method, the previous bindings are replaced by

Ruby is a Meritocracy

I recently read Russ Olsen's book Design Patterns in Ruby. In it, the author makes a wonderful distinction between statically vs. dynamically typed languages, which is different from all other comparisons I've seen.

How to Benchmark Rails Views

This post explores the Benchmarkable module provided by Active Support to measure the execution time for rendering Rails views.

Autoloading Modules in Rails

Autoloading modules allows you to speed up the initialization of your library by lazily loading the code you need. This post explores how autoload method works.

How to Benchmark Ruby Code

The Benchmark module in the Ruby standard library helps you measure and report the time used to execute your code. This post explores three useful methods in this module, which allow you to measure and compare the execution times of code as well as warm up the code to stabilize

Understanding Active Model: Attribute Assignment

In this post, we will explore the AttributeAssignment module in Active Model, which allows you to set the model's attributes by passing in a hash, a feature commonly used by Active Record models.

How to Debug Rails Source Code

Reading the Rails source code is a great way to understand how a feature works in Rails. However, stepping through the specific Rails method you're interested in is even better. You can inspect the local variables, follow the conditional path, and learn exactly what's happening behind the scenes. This post

Understanding Authenticity Tokens in Rails

This post explores CSRF vulnerability and how Rails mitigates it using authenticity tokens. We will will learn why they're needed, how they're generated, how Rails uses them to verify the requests, and how to disable them for specific requests.

Metaprogramming in Ruby

Metaprogramming in Ruby enables you to produce elegant, clean, and beautiful programs as well as unreadable, complex code that’s not maintainable. This book teaches you the powerful metaprogramming concepts in Ruby, and how to use them judiciously.

How to Get an Object's Class Name in Rails

This post explores a few different ways in which you can get an object's class name in both Ruby and Rails.

The Difference Between nil?, empty?, and blank? in Ruby

In ruby, you can use the nil? method on an instance to check if it’s nil. However, ruby also provides empty? and there’s a blank? method in Rails. For a new ruby programmer, it can get quite confusing. This post tries to explain which method to use when.

A Deep Dive Into Database Migrations in Rails

Like source code, database schema changes and evolves over time. Migrations are a feature of Active Record that allows you to manage the database schema changes gracefully, without writing any SQL. This post contains my notes on Active Record migrations from the official Rails guides. Key Points * Think of each

Attributes API in Rails

Sometimes, you want to set default values on your ActiveRecord objects and convert them to a different type. Rails provides a handy attribute method that lets us do that, and much more. In this post, we will try to understand how to use the attributes API to achieve this. First,

How to Get the Current Absolute URL in Rails

Every Rails controller includes two accessor methods pointing to the request and the response objects associated with the current HTTP request cycle. The request method returns an instance of the ActionDispatch::Request class, which wraps the HTTP request and provides a nice API to inspect the request. Use original_url

How to Rename a Database Column in Rails

Solution 1: Undo Last Migration If it is a simple typo in the last migration, use the db:rollback command to undo the last change. Then open the previous migration file, fix your typo, and rerun the migration. Make sure that no new data is inserted in the table or

How to Check if a Variable is Defined in Ruby

Ruby provides a handy defined?(expression) keyword that tests if the expression refers to anything recognizable. The expression can be an object, a variable that’s initialized, method name, etc. If Ruby can’t resolve the expression, it returns nil. Otherwise, it returns a string describing the expression. Here are

Metal Controller in Rails

The ActionController::Base is the great-grandfather of all Rails controllers, but doesn't get much attention. In this post, we will examine this Metal class and how it works.

Active Job: How Does It Work?

In this article, I explain the journey of a background job, from its creation to execution. We will learn how it’s configured and enqueued, and how an adapter invokes it. We will also see the different ways to configure a job.

Can You Spot the Error?

Do you see the error in this simple Ruby snippet?

Up and Running with Minitest

I love minitest. Minitest is simple. There’re a few ways to write tests, and they are so intuitive. I learned it last year, when I got into Ruby, and since then I haven’t really felt the need to dive into the docs that frequently. It just works. That

Ruby Shortcut to Call a Method with Each Array Item as Parameter

As a Ruby programmer, you probably know the &: shortcut to call a method on each item in an array. For example, this snippet will call the to_s method on :foo and :bar. [:foo, :bar].each(&:to_s) The above code is similar to: [:foo, :bar].each do |item| item.

CDPATH: Easily Navigate Directories in the Terminal

You know about the PATH environment variable. Did you know about CDPATH? If you’ve been typing long cd commands like me, this post is for you. I came across this gem this morning, while reading Daniel Barrett’s Efficient Linux at the Command Line. It instructs the cd command

How to Manage Environment Variables in Rails

Now you might think it’s so easy to access them using the ENV hash. Why do we need a different way? Well, a very common problem when working on multiple Rails applications on the same machine during development is that these applications might have environment variables with the same

Why You Need Strong Parameters in Rails

In this post, I will explain the Mass Assignment vulnerability and how you can use the Rails strong parameters API to address it.

Understanding Rails Parameters

If you are building a dynamic web application, you will need to access the user-submitted data on the server. Maybe the user uploaded a photo, wrote a comment, posted a tweet, or clicked a link that includes the id of the article they want to read. How do you access

Useful Linux Commands

Learning the Linux command line, like becoming an accomplished pianist, is not something that we pick up in an afternoon. It takes years of practice. The Linux Command Line, William E. Shotts Since I switched to Ruby on Rails from .NET, I find myself increasingly using the terminal every day.

Running a Single Test with Spaces in Minitest

In Rails, if you want to run a specific test without the others in the file, you can pass the method’s name to the --name flag. def test_controller_name # assert ... end > ruby -I test test/controller/renderer_test.rb --name test_controller_name But, Rails also provides a

How to Access Rails ActiveRecord Models Inside a Rake Task

If you’ve been working with Ruby on Rails for a while, you’ve come across Rake. Written by the late Jim Weirich, Rake is to Ruby what Make is to C. It’s very easy to create custom Rake tasks to simplify your development workflows. Rails even provides a

How to Convert a Ruby Object to Hash

Let’s say you have a Product object with properties @name = "Table" & @price = 10. What’s the best way in Rails to convert this object to the Hash { name: "Table", price: 10 }? Why? Earlier this evening, I was trying to write an integration test to post some data to the

How to Access Hash Values Like Methods using OrderedOptions

In Ruby, if you want to access hash values like methods on an object, use ActiveSupport::OrderedOptions. This class inherits from Hash and provides dynamic accessor methods. Typically, you’d do this with a Hash. person = { name: "Jason", company: "Basecamp" } person[:company] # 'Basecamp' Using OrderedOptions, you can write require "active_

Useful Ruby Gems

Although Rails provides great defaults out-of-the-box, you can easily extend it with Ruby gems. Here are some gems that I find myself using every time I start a new Rails project. Semantic Logger Semantic Logger is a feature-rich logging framework, and replacement for existing Ruby & Rails loggers. gem "amazing_print"

How to Access Route Helpers from Rails Console

This post shows a simple way to check the output of URL and path helpers directly from the Rails console. We will also see how to access these helpers in your models.

Why Turbo Uses Event Capturing

I was reading the source of the Turbo library and came across following code in link_click_observer.ts, which executes whenever the session starts (when the page loads) and Turbo starts observing the links and forms: start() { if (!this.started) { addEventListener("click", this.clickCaptured, true) this.started = true } } clickCaptured

Why Choose `let` Over instance variables in RSpec

Repetitive setup code in tests makes it difficult to refactor the tests. It also distracts and shifts our focus from the business logic that we’re trying to test with the setup details. This post explains three ways to reduce the setup duplication in your tests. Here’s a simple

Inline Edits using Turbo Frames

This post explains how to use Turbo Frames to make your web application behave like a Single-Page Application without using any JavaScript.

Turbo Drive Essentials

I spent the last night reading up on the Turbo Drive, a part of Hotwire front-end framework that Rails 7 ships with. The core value proposition of Hotwire is that all the logic lives on the server, and the browser deals just with the final HTML. This post tries to

Launching Multiple Processes with a Single Command in Rails

An application doesn’t exist in isolation. Usually, it depends on other processes to work correctly, such as a database, JavaScript / CSS compilers, Redis, etc. So far, whenever I started the Rails app, I launched these supporting processes in multiple terminal windows. This week, I learned a new way to

class_eval vs. instance_eval in Ruby

This post explains the difference between class_eval and instance_eval methods in Ruby. If you keep getting confused between them when reading or writing Ruby code, it should clarify things a little. Consider the Greeting class, which forms the basis of other examples. class_eval class_eval evaluates the

A Brief Introduction to Hotwire

This post introduces Hotwire, the suite of front-end frameworks shipped with Rails 7. It starts with a brief overview of the existing approaches to building web applications, introduces Hotwire, and wraps up with a short description of the different sub-frameworks that make Hotwire. We’ll also see how these frameworks

How to Setup Tailwind 3 on Rails

Update: Tailwind documentation has since added the installation steps with Rails. Even though the official Tailwind documentation has installation instructions for various client-side frameworks, it is missing one for Rails. Most of the tutorials work with the older versions of Tailwind. With version 3 released a few days ago, I

Couldn't Find Handler For: puma, thin, falcon, webrick

This morning, I was trying to learn Rack and how Rails uses it. So I created a new gem using the bundle gem command. Then I added a config.ru file with the following code. class App def call(env) ['200', {'Content-Type' => 'text/html'}, ['Hello World']] end end run App.

All the Database Tasks in Rails

Once you start programming in Rails, you inevitably come across db:migrate, which applies the migration to your database. Then you make a mistake and learn about db:rollback to revert the previous migration. After programming for a while, you stumble upon db:reset, to drop and recreate your database,

How to Drop a Table in Rails

So you created a migration to add a table that you thought you were going to need. You also ran that migration so that table is in your database. Now, you don’t need it anymore and want to drop it from the database. How do you remove that table?

How to Debug Ruby Code

For a long time, I delayed learning Ruby as I didn’t know how to debug Ruby code. Coming from a .NET background, I was used to debugging C# in Visual Studio, with its powerful support of stepping in and out, dragging breakpoints, changing variables on the fly, and a

How to Test Rails Source Code

One of the best ways to understand any codebase is to read the tests, and Rails is no exception. In this post, we will learn “how to run the tests” included in the Rails codebase. Specifically, we will learn how to: 1. Run the entire Rails test suite 2. Run

Include and Extend

Here’s a neat trick I learned today. Typically, when a class includes a module, the module methods become instance methods on the including class. However, with just a little metaprogramming, a module can provide both instance and class methods to the including class. Here’s how that works. module

Proc vs. Lambda

Though they might look the same, the Proc and Lambdas have few differences. The first key difference is that the return keyword means different things. In a lambda, return just returns from the lambda. In a proc, return behaves differently. Rather than return from the proc, it returns from the

What is Binding in Ruby

A Binding is a whole scope packaged as an object. It allows you to encapsulate and carry the scope around. Later, you can execute a piece of code in the context of that binding, using eval. The Kernel#binding method returns the current binding object. A binding object encapsulates the

Modifying Objects in Place

Every time you create or copy something in memory, you add work for GC. Here are some tips from the book Ruby Performance Optimization to write code without using too much memory. Modify strings in-place. Instead of making a changed copy, you change the original string. Look for “bang!” functions,

Class Metaprogramming in Ruby

A Ruby class definition is just regular code that runs. When you use the class keyword to create a class, you aren’t just dictating how objects will behave in the future. You are actually running code. You can put any code in a class definition, and it returns the

Bloc, Proc, and a Lambda

There are at least three places in Ruby where you can package code to be executed later. In a block, a proc/lambda, and a method. Block A block is a chunk of code you can associate with method invocations, almost as if they were parameters. You can use code

Rails Middleware

Here’s a list of middleware Rails uses in a development environment. You can view the middleware by running the bin/rails middleware command from your application directory. Rack::MiniProfiler Displays speed badge for every HTML page. Designed to work both in production and in development. ActionDispatch::HostAuthorization Guards from

Caching in Rails

These are the notes I took while reading the Rails caching guide. Caching is one of the most effective ways to boost an application’s performance. It stores content generated during the request-response cycle to reuse it when responding to similar requests. Rails supports caching out of the box, and

A Brief Introduction to Rake

Rake is a task runner written in Ruby. It performs repetitive tasks, such as 1. Making database backup 2. Running tests 3. Watch for file changes and compile the changed files In the words of late Jim Weirich, the creator of rake, The essence of rake is to take a