RubyGuides
Share this post!

Ruby Is Hiding Errors From You!

Ruby will intentionally hide some exceptions from you.

Sometimes this can be useful. Like when using the Kernel#loop method with a block, the loop will stop when a StopIteration exception is raised.

But other times this can make your debugging sessions a lot harder.

Let’s see some examples!

Hidden Exception: Comparable Module + <=> Method

The first example involves the Comparable module & the <=> method.

Here’s the example:

Let’s talk about this example.

First we have a class named MyObject, with one attr_accessor value, and the inclusion of the Comparable module, which adds comparison methods (like ==, <, >) to our class.

These comparison methods are based on the <=> method.

Just like Enumerable methods are based on the each method.

After the class definition, we are creating two objects (MyObject.new) with the same value (10). Notice that even if they have the same values they are different objects, this is important.

Now if we compare these two objects mo1 & mo2 we get false

Why?

Because we have an error in our <=> method, but Ruby is hiding that error!

Look closely…

Can you spot the error?

If you found it good job! If not that’s ok 🙂

Here it is:

See this valuee?

Turns out we have a typo!

Normally we would get a NoMethodError exception & we would know what the problem is pretty quickly. But not in this example.

The good news is that since Ruby 2.3 this has changed. You can see the error now since it’s no longer hidden.

Another reason to upgrade if you are still running older Ruby versions.

Hidden Exception: Numeric Object + Coercion Method

Another example of hidden exception is with Numeric objects (Float, Integer) plus the coerce method.

Here’s an example:

This is another MyObject class, but with new methods, + & coerce.

The coerce method allows you to work with two incompatible types & transform them into the same type so they can work together.

In this case our class represents some numeric value, which could be a number of seconds, a price or anything like that…

And we want to be able to do these kind of operations:

The first one (mo1 + 20) is easy since we control the + method in our class.

But what about the Integer class?

We could change Integer’s + method to implement this, but that’s probably not a good idea 🙂

The solution?

Implement the coerce method in your own class.

One thing the + method on Integer will do is to check if your object implements this method, and if it does it will call it.

Now, remember the code example at the start of this section?

If we try to do this:

We want to see 30, because the value for mo1 is 10. But what we see is this:

Same problem as before!

An error is being hidden from us inside the coerce method.

This: mo.valuee = other

Again we have a typo, but that’s not what the error is saying!

I have good news for you, this behavior is changing in Ruby 2.5, so that will be another hidden error going away so you don’t have to worry about it.

Summary

As you can see these are good examples on why you want to avoid hiding exceptions. You can learn more about exceptions in my book, Ruby Deep Dive.

I would appreciate if you shared this post with your friends so more people can see it.

Thanks for reading!

Leave a Comment: