Symmetric, self-referential has-one relationships in Rails

Suppose you have a Person model, and you want to represent that a Person can have a spouse. That's a self-referential relationship: the Spouse would be obviously be another Person. What makes this example a little more interesting than a standard self-referential has-one relationship is that the relationship is symmetric. You could, in theory, create the relationship from either perspective.

If we have Alice and Bob:

       alice = Person.create!
       bob = Person.create!

Then

       alice.spouse = bob

should be just as valid as

       bob.spouse = alice

The problem is that if you set the relationship up as

       class Person < class_name =""> 'Person'

       end

Then whoever you add the spouse to first "has" the spouse.

       alice.spouse = bob

would mean that

       bob.spouse

returns nil

That's clearly wrong. We want to be able to query Bob for his spouse and return Alice.

We tried a number of solutions, including overriding the getter or setter, but the solution we found easiest was to build the relationship ourselves and not use any of the built-in Rails relationship functions.

       def spouse
         if @spouse.nil? && !spouse_id.blank? || !@spouse.nil? && @spouse.id != spouse_id
            @spouse = spouse_id.blank? ? nil : Person.find(spouse_id)
         end
         @spouse
       end

       def spouse=(new_spouse)
         raise(ApplicationError, "Both persons must be saved records in order to connect.") if !new_spouse.nil? && (new_record? || new_spouse.new_record?)
 
         unless new_spouse.nil?
           new_spouse.get_a_divorce
           new_spouse.set_spouse_and_id(self)
           new_spouse.save!
         end

         get_a_divorce
         set_spouse_and_id(new_spouse)
         save!
       end

       def spouse_id=(new_spouse_id)
         self.spouse = (new_spouse_id.blank? ? nil : Person.find(new_spouse_id))
         save!
       end

   private

       def set_spouse_and_id(new_spouse)
         @spouse = new_spouse
         self[:spouse_id] = new_spouse.nil? ? nil : new_spouse.id
       end

       def get_a_divorce
         unless spouse.nil?
           spouse.set_spouse_and_id(nil)
           spouse.save!
         end
       end

The main points are:
Your setter has to make sure that both sides of the relationship are disconnected before joining because you never know if the key is stored in the objects you're currently dealing with, or in their *former* partners.
Your getter has to do a search for your ID if your object doesn't have a foreign-key reference because the key could be stored on either side.