Question

I wrote a very simple User class. The instance variable email has a reader accessor and my own writer accessor that validates the email address with a regex.

class User
    attr_reader :email

    def email=(value)
        if (value =~ /^[a-z\d\-\_\+\.]+@([a-z\d\-]+\.)+[a-z]+$/)
            @email = value
        else
            # bonus question: is ArgumentError the right error type to use here?
            raise ArgumentError, "#{value} is not a valid email address."
        end
    end
end

I wrote the following test:

require 'test/unit'
require_relative '../lib/user'

class TC_UserTest < Test::Unit::TestCase
    def setup
        @user = User.new()
    end

    def test_email
        # using the writer accessor
        @user.email = '[e-mail]'
        # bypassing the writer accessor. evil.
        @user.email[4] = '#'
        assert_equal('[e-mail]', @user.email)
    end
end

By using the reference given to me by the reader accessor, I am able to manipulate the email instance variable without going through the writer accessor.

The same principe would apply to any data type that allows manipulation without outright assigning a new value with =

Am I being overzealous? I just want to write robust code. Is there a way to ensure that my email address can only be set using the writer accessor?

I’m new to the language and I’m trying to get a feel for the best practices.

Answer 1

To do what you’re trying to do, my advice is to move the regexp into its own validation method.

Better still, don’t write an email regexp unless you really want to do it right.

Use a gem instead: https://github.com/SixArm/sixarm_ruby_email_address_validation

After you set the email, freeze it with http://ruby-doc.org/core-1.9.3/Object.html#method-i-freeze

Bonus answer: yes, ArgumentError is the right error type in general. If you’re using Rails, consider using the Rails validation methods.