All Men Are Mortal

What All Men Are Mortal Actually Does

The name sounds dramatic but the code is straightforward. All Men Are Mortal is a Ruby concern you drop into your models to make nil values behave predictably instead of raising errors everywhere. When you call .present?, .blank?, .to_i, .to_s, or a few other common methods on nil, it doesn't crash — it returns a sensible default based on context. I ran into this problem early on building an API. We had nested API calls where one level of data was optional. When the outer request returned null for an address object, calling address.city would raise NoMethodError. Every form validator, every presenter, every background job needed a rescue block or an explicit nil check. It was everywhere.

Where You Actually Need It

Typically you include it in ApplicationRecord or in individual models where nil data comes in from external sources. Rails serializers, third-party webhooks, and GraphQL resolvers are the usual culprits. If your app only touches your own database through standard ActiveRecord CRUD, you probably don't need it. The cases where it earns its weight are the ones where data enters your system from outside it. In practice I include it like this: include AllMenAreMortal

Then in a model where external data gets mapped: attributes = external_payload.permit(...).to_h\nMyModel.create(attributes) The concern wires up after the object initializes, so nil fields stay nil but respond to whatever methods the concern defines.

The Installation Part

Add the gem to your Gemfile: gem 'all-men-are-mortal' Run bundle install. Then include it in the model or base class you want to protect.

The GitHub repository lives at github.com/leandrocp/all-men-are-mortal. There isn't a separate downloadable binary. It's a standard Ruby gem, so bundle is all you need.

How It Works Under the Hood

The core idea is monkey-patching the NilClass. That sounds risky but the gem is fairly contained. It defines a small set of methods on NilClass and returns typed defaults: nil.to_i returns 0\nnil.to_s returns \"\"\nnil.present? returns false\nnil.blank? returns true More interestingly it handles chained calls through a proxy object. If you call nil.something_that_returns_nil, it keeps returning a proxy instead of bombing out. That means nested nil access like nil.address.city still returns a nil-like proxy rather than raising.

I spent a day debugging why a specific line in our webhook handler was silently swallowing data. The issue was that nil.address.street.upcase returned an empty string instead of nil, which cascaded into a validation that thought the field was present when it wasn't. The workaround was to check the raw database value directly using read_attribute instead of going through the accessor.

Edge Cases That Will Bite You

There are two things beginners miss about this gem. First, it does not protect against nil in conditionals the way you might expect in all contexts. Active Record queries that filter on nil columns still behave according to SQL semantics. If you're doing Person.where(phone_number: nil), that works fine. But if you're doing a chain like Person.joins(:addresses).where(addresses: { city: nil }), the nil you get back from the joined relation is still a real nil from the database layer, not the proxy. So the concern only covers Ruby-level method calls, not SQL-level nil comparison. Second, caching becomes weird. Rails fragments cache the result of method calls. When nil.to_s is patched to return \"\", the cache key sees an empty string where it previously saw nil. This can cause stale cache hits in edge cases. I found this when our dashboard widget started showing blank phone numbers for users who had never entered one. The fix was invalidating the relevant fragment cache after the first nil-to-proxy transition, which is usually on the first request after deployment.

When It Falls Apart

This gem is not a silver bullet. It breaks down in three situations. The first is when you need strict type enforcement. If your service layer relies on nil meaning \"not set\" versus \"empty string set\", the proxy blur between those two states will cause logic errors. I learned this the hard way in a billing module where a nil discount code and an empty-string discount code had very different meanings. The workaround was to wrap the model behind a value object that explicitly checked nil versus blank before delegating. The second is performance under heavy write load. The NilClass modifications add a small overhead to every nil object creation. On a typical app it is negligible. On a service processing thousands of nil-heavy records per second, I measured about a 3 to 5 percent slowdown in benchmark tests. It is not catastrophic but it is measurable.

The third is when you migrate between Rails versions. The gem pins to specific Rails releases and the NilClass patching strategy changes slightly between major versions. Upgrading from Rails 6 to Rails 7 required me to update the gem version and retest every endpoint that touched unvalidated incoming JSON.

What To Do Instead In Some Cases

If your problem is just nil-safe access to nested associations, the built-in Rails approach of using try or the safe navigation operator often does the same job without patching NilClass. The tradeoff is that safe navigation returns nil on every failure, which means you lose the ability to chain methods like .to_s naturally. For a lighter alternative, consider wrapping only the models that need it instead of applying it globally. That keeps the NilClass patch localized and makes it easier to reason about where the behavior is active. I switched half our models away from the global concern to explicit null object classes after the caching issue showed up. The null objects were more verbose to write but they made the nil-handling logic visible in the code instead of hidden inside a monkey patch.

A Quick Setup Checklist

Add the gem and run bundle install.\nInclude it in the model or ApplicationRecord.\nAudit any service classes that compare nil explicitly with == or eql?.\nTest your webhook parsers and serializer outputs after inclusion.\nWatch for fragment cache changes in the first 24 hours.\nRe-run your integration tests after any Rails upgrade. The concrete takeaway is that All Men Are Mortal removes a lot of defensive nil-checking from your code, but it trades that cleanliness for a layer of silent coercion. That trade is worth it when your data sources are messy and your time is short. It is not worth it when your domain logic depends on distinguishing between absence and emptiness.